En esta página

QGraphicsItem Class

La clase `QGraphicsItem` es la clase base de todos los elementos gráficos de un ` QGraphicsScene`. Más información...

Encabezado: #include <QGraphicsItem>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Heredado por:

QAbstractGraphicsShapeItem, QGraphicsItemGroup, QGraphicsLineItem, QGraphicsObject y QGraphicsPixmapItem

Tipos públicos

enum CacheMode { NoCache, ItemCoordinateCache, DeviceCoordinateCache }
enum GraphicsItemChange { ItemEnabledChange, ItemEnabledHasChanged, ItemPositionChange, ItemPositionHasChanged, ItemTransformChange, …, ItemScenePositionHasChanged }
enum GraphicsItemFlag { ItemIsMovable, ItemIsSelectable, ItemIsFocusable, ItemClipsToShape, ItemClipsChildrenToShape, …, ItemContainsChildrenInShape }
flags GraphicsItemFlags
enum PanelModality { NonModal, PanelModal, SceneModal }
enum { Type, UserType }

Funciones públicas

QGraphicsItem(QGraphicsItem*parent = nullptr)
virtual ~QGraphicsItem()
bool acceptDrops() const
bool acceptHoverEvents() const
bool acceptTouchEvents() const
Qt::MouseButtons acceptedMouseButtons() const
virtual void advance(int phase)
virtual QRectF boundingRect() const = 0
QRegion boundingRegion(const QTransform&itemToDeviceTransform) const
qreal boundingRegionGranularity() const
QGraphicsItem::CacheMode cacheMode() const
QList<QGraphicsItem *> childItems() const
QRectF childrenBoundingRect() const
void clearFocus()
QPainterPath clipPath() const
virtual bool collidesWithItem(const QGraphicsItem*other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
virtual bool collidesWithPath(const QPainterPath&path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const
QList<QGraphicsItem *> collidingItems(Qt::ItemSelectionMode modo = Qt::IntersectsItemShape) const
QGraphicsItem *commonAncestorItem(const QGraphicsItem*other) const
virtual bool contains(const QPointF&punto) const
QCursor cursor() const
QVariant data(int key) const
QTransform deviceTransform(const QTransform&viewportTransform) const
qreal effectiveOpacity() const
void ensureVisible(const QRectF&rect = QRectF(), int xmargin = 50, int ymargin = 50)
void ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)
bool filtersChildEvents() const
QGraphicsItem::GraphicsItemFlags flags() const
QGraphicsItem *focusItem() const
QGraphicsItem *focusProxy() const
void grabKeyboard()
void grabMouse()
QGraphicsEffect *graphicsEffect() const
QGraphicsItemGroup *group() const
bool hasCursor() const
bool hasFocus() const
void hide()
Qt::InputMethodHints inputMethodHints() const
void installSceneEventFilter(QGraphicsItem*filterItem)
bool isActive() const
bool isAncestorOf(const QGraphicsItem*child) const
bool isBlockedByModalPanel(QGraphicsItem**blockingPanel = nullptr) const
bool isClipped() const
bool isEnabled() const
bool isObscured(const QRectF&rect = QRectF()) const
bool isObscured(qreal x, qreal y, qreal w, qreal h) const
virtual bool isObscuredBy(const QGraphicsItem*item) const
bool isPanel() const
bool isSelected() const
bool isUnderMouse() const
bool isVisible() const
bool isVisibleTo(const QGraphicsItem*parent) const
bool isWidget() const
bool isWindow() const
QTransform itemTransform(const QGraphicsItem*other, bool*ok = nullptr) const
QPainterPath mapFromItem(const QGraphicsItem*elemento, const QPainterPath&trayecto) const
QPointF mapFromItem(const QGraphicsItem*item, const QPointF&point) const
QPolygonF mapFromItem(const QGraphicsItem*item, const QPolygonF&polygon) const
QPolygonF mapFromItem(const QGraphicsItem*elemento, const QRectF&rectángulo) const
QPolygonF mapFromItem(const QGraphicsItem*item, qreal x, qreal y, qreal w, qreal h) const
QPointF mapFromItem(const QGraphicsItem*item, qreal x, qreal y) const
QPainterPath mapFromParent(const QPainterPath&path) const
QPointF mapFromParent(const QPointF&point) const
QPolygonF mapFromParent(const QPolygonF&polígono) const
QPolygonF mapFromParent(const QRectF&rect) const
QPolygonF mapFromParent(qreal x, qreal y, qreal w, qreal h) const
QPointF mapFromParent(qreal x, qreal y) const
QPainterPath mapFromScene(const QPainterPath&path) const
QPointF mapFromScene(const QPointF&punto) const
QPolygonF mapFromScene(const QPolygonF&polígono) const
QPolygonF mapFromScene(const QRectF&rect) const
QPolygonF mapFromScene(qreal x, qreal y, qreal w, qreal h) const
QPointF mapFromScene(qreal x, qreal y) const
QRectF mapRectFromItem(const QGraphicsItem*item, const QRectF&rect) const
QRectF mapRectFromItem(const QGraphicsItem*item, qreal x, qreal y, qreal w, qreal h) const
QRectF mapRectFromParent(const QRectF&rect) const
QRectF mapRectFromParent(qreal x, qreal y, qreal w, qreal h) const
QRectF mapRectFromScene(const QRectF&rect) const
QRectF mapRectFromScene(qreal x, qreal y, qreal w, qreal h) const
QRectF mapRectToItem(const QGraphicsItem*item, const QRectF&rect) const
QRectF mapRectToItem(const QGraphicsItem*item, qreal x, qreal y, qreal w, qreal h) const
QRectF mapRectToParent(const QRectF&rect) const
QRectF mapRectToParent(qreal x, qreal y, qreal w, qreal h) const
QRectF mapRectToScene(const QRectF&rect) const
QRectF mapRectToScene(qreal x, qreal y, qreal w, qreal h) const
QPainterPath mapToItem(const QGraphicsItem*item, const QPainterPath&path) const
QPointF mapToItem(const QGraphicsItem*item, const QPointF&point) const
QPolygonF mapToItem(const QGraphicsItem*item, const QPolygonF&polygon) const
QPolygonF mapToItem(const QGraphicsItem*item, const QRectF&rect) const
QPolygonF mapToItem(const QGraphicsItem*item, qreal x, qreal y, qreal w, qreal h) const
QPointF mapToItem(const QGraphicsItem*item, qreal x, qreal y) const
QPainterPath mapToParent(const QPainterPath&path) const
QPointF mapToParent(const QPointF&point) const
QPolygonF mapToParent(const QPolygonF&polígono) const
QPolygonF mapToParent(const QRectF&rect) const
QPolygonF mapToParent(qreal x, qreal y, qreal w, qreal h) const
QPointF mapToParent(qreal x, qreal y) const
QPainterPath mapToScene(const QPainterPath&path) const
QPointF mapToScene(const QPointF&point) const
QPolygonF mapToScene(const QPolygonF&polígono) const
QPolygonF mapToScene(const QRectF&rect) const
QPolygonF mapToScene(qreal x, qreal y, qreal w, qreal h) const
QPointF mapToScene(qreal x, qreal y) const
void moveBy(qreal dx, qreal dy)
qreal opacity() const
virtual QPainterPath opaqueArea() const
virtual void paint(QPainter*painter, const QStyleOptionGraphicsItem*option, QWidget*widget = nullptr) = 0
QGraphicsItem *panel() const
QGraphicsItem::PanelModality panelModality() const
QGraphicsItem *parentItem() const
QGraphicsObject *parentObject() const
QGraphicsWidget *parentWidget() const
QPointF pos() const
void removeSceneEventFilter(QGraphicsItem*filterItem)
void resetTransform()
qreal rotation() const
qreal scale() const
QGraphicsScene *scene() const
QRectF sceneBoundingRect() const
QPointF scenePos() const
QTransform sceneTransform() const
void scroll(qreal dx, qreal dy, const QRectF&rect = QRectF())
void setAcceptDrops(bool on)
void setAcceptHoverEvents(bool enabled)
void setAcceptTouchEvents(bool habilitado)
void setAcceptedMouseButtons(Qt::MouseButtons botones)
void setActive(bool active)
void setBoundingRegionGranularity(qreal granularidad)
void setCacheMode(QGraphicsItem::CacheMode modo, const QSize&tamaño_lógico_de_la_caché = QSize())
void setCursor(const QCursor&cursor)
void setData(int key, const QVariant&value)
void setEnabled(bool enabled)
void setFiltersChildEvents(bool enabled)
void setFlag(QGraphicsItem::GraphicsItemFlag flag, bool enabled = true)
void setFlags(QGraphicsItem::GraphicsItemFlags flags)
void setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)
void setFocusProxy(QGraphicsItem*item)
void setGraphicsEffect(QGraphicsEffect*effect)
void setGroup(QGraphicsItemGroup*group)
void setInputMethodHints(Qt::InputMethodHints hints)
void setOpacity(qreal opacity)
void setPanelModality(QGraphicsItem::PanelModality panelModality)
void setParentItem(QGraphicsItem*nuevoPadre)
void setPos(const QPointF&pos)
void setPos(qreal x, qreal y)
void setRotation(qreal ángulo)
void setScale(qreal factor)
void setSelected(bool selected)
void setToolTip(const QString&toolTip)
void setTransform(const QTransform&matriz, bool combinar = false)
void setTransformOriginPoint(const QPointF&origin)
void setTransformOriginPoint(qreal x, qreal y)
void setTransformations(const QList<QGraphicsTransform *>&transformaciones)
void setVisible(bool visible)
void setX(qreal x)
void setY(qreal y)
void setZValue(qreal z)
virtual QPainterPath shape() const
void show()
void stackBefore(const QGraphicsItem*sibling)
QGraphicsObject *toGraphicsObject()
const QGraphicsObject *toGraphicsObject() const
QString toolTip() const
QGraphicsItem *topLevelItem() const
QGraphicsWidget *topLevelWidget() const
QTransform transform() const
QPointF transformOriginPoint() const
QList<QGraphicsTransform *> transformations() const
virtual int type() const
void ungrabKeyboard()
void ungrabMouse()
void unsetCursor()
void update(const QRectF&rect = QRectF())
void update(qreal x, qreal y, qreal width, qreal height)
QGraphicsWidget *window() const
qreal x() const
qreal y() const
qreal zValue() const

Funciones protegidas

virtual void contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
virtual void dragEnterEvent(QGraphicsSceneDragDropEvent *event)
virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
virtual void dragMoveEvent(QGraphicsSceneDragDropEvent *event)
virtual void dropEvent(QGraphicsSceneDragDropEvent *event)
virtual void focusInEvent(QFocusEvent *event)
virtual void focusOutEvent(QFocusEvent *event)
virtual void hoverEnterEvent(QGraphicsSceneHoverEvent *event)
virtual void hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event)
virtual void inputMethodEvent(QInputMethodEvent *event)
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const
virtual QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
virtual void keyPressEvent(QKeyEvent *event)
virtual void keyReleaseEvent(QKeyEvent *event)
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event)
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event)
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
void prepareGeometryChange()
virtual bool sceneEvent(QEvent *event)
virtual bool sceneEventFilter(QGraphicsItem *watched, QEvent *event)
void updateMicroFocus()
virtual void wheelEvent(QGraphicsSceneWheelEvent *event)
T qgraphicsitem_cast(QGraphicsItem *item)

Descripción detallada

Proporciona una base sencilla para crear tus propios elementos personalizados. Esto incluye la definición de la geometría del elemento, la detección de colisiones, la implementación de su dibujo y la interacción con el elemento a través de sus controladores de eventos. QGraphicsItem forma parte del marco de trabajo Graphics View

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

Para mayor comodidad, Qt proporciona un conjunto de elementos gráficos estándar para las formas más comunes. Estos son:

Toda la información geométrica de un elemento se basa en su sistema de coordenadas local. La posición del elemento, ` pos()``, es la única función que no opera en coordenadas locales, ya que devuelve una posición en coordenadas del elemento padre. El apartado «Sistema de coordenadas de la vista gráfica» describe el sistema de coordenadas con detalle.

Se puede establecer si un elemento debe estar visible (es decir, dibujado y aceptando eventos) llamando a ` setVisible()`. Al ocultar un elemento, también se ocultarán sus elementos hijos. Del mismo modo, se puede habilitar o deshabilitar un elemento llamando a ` setEnabled()`. Si se desactiva un elemento, todos sus hijos también quedarán desactivados. Por defecto, los elementos están visibles y activados. Para alternar si un elemento está seleccionado o no, primero hay que habilitar la selección estableciendo el indicador « ItemIsSelectable » y, a continuación, llamar a ` setSelected()`. Normalmente, la selección se alterna en la escena como resultado de la interacción del usuario.

Para crear tu propio elemento gráfico, primero debes crear una subclase de `QGraphicsItem` y, a continuación, empezar por implementar sus dos funciones públicas virtuales puras: ` boundingRect()`, que devuelve una estimación del área pintada por el elemento, y ` paint()`, que implementa la pintura propiamente dicha. Por ejemplo:

class SimpleItem : public QGraphicsItem
{
public:
    QRectF boundingRect() const override
    {
        qreal penWidth = 1;
        return QRectF(-10 - penWidth / 2, -10 - penWidth / 2,
                      20 + penWidth, 20 + penWidth);
    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
               QWidget *widget) override
    {
        painter->drawRoundedRect(-10, -10, 20, 20, 5, 5);
    }
};

La función boundingRect() tiene muchos fines diferentes. QGraphicsScene basa el índice de su elemento en boundingRect(), y QGraphicsView la utiliza tanto para descartar elementos invisibles como para determinar el área que debe recomponerse al dibujar elementos superpuestos. Además, los mecanismos de detección de colisiones de QGraphicsItem utilizan boundingRect() para proporcionar un corte eficiente. El algoritmo de colisión de alta precisión de collidesWithItem() se basa en la llamada a shape(), que devuelve un contorno preciso de la forma del elemento como un QPainterPath.

QGraphicsScene boundingRect() y () esperan que todos los elementos permanezcan sin cambios a menos que se les notifique lo contrario. Si deseas modificar la geometría de un elemento de cualquier forma, primero debes llamar a () para permitir que actualice su registro. shape prepareGeometryChange QGraphicsScene

La detección de colisiones puede realizarse de dos maneras:

  1. Reimplementa ` shape()` para devolver una forma precisa de tu elemento y utiliza la implementación predeterminada de ` collidesWithItem()` para realizar la intersección entre formas. Esto puede resultar bastante costoso si las formas son complejas.
  2. Reimplementa ` collidesWithItem()` para proporcionar tu propio algoritmo personalizado de colisión entre elementos y formas.

Se puede llamar a la función contains() para determinar si el elemento contiene un punto o no. Esta función también puede ser reimplementada por el propio elemento. El comportamiento predeterminado de contains() se basa en llamar a shape().

Los elementos pueden contener otros elementos y, a su vez, estar contenidos en otros elementos. Todos los elementos pueden tener un elemento padre y una lista de elementos hijos. A menos que el elemento no tenga padre, su posición se expresa en coordenadas del padre (es decir, las coordenadas locales del padre). Los elementos padres propagan tanto su posición como su transformación a todos los elementos hijos.

Varias transformaciones de sistemas de coordenadas

Transformaciones

QGraphicsItem admite transformaciones proyectivas, además de su posición base, pos(). Existen varias formas de modificar la transformación de un elemento. Para transformaciones sencillas, puede llamar a cualquiera de las funciones de conveniencia ` setRotation()` o ` setScale()`, o bien puede pasar cualquier matriz de transformación a ` setTransform()`. Para un control avanzado de las transformaciones, también tiene la opción de establecer varias transformaciones combinadas llamando a ` setTransformations()`.

Las transformaciones de los elementos se acumulan de padre a hijo, por lo que si tanto un elemento padre como uno hijo se giran 90 grados, la transformación total del hijo será de 180 grados. Del mismo modo, si el elemento padre se escala al doble de su tamaño original, sus hijos también serán el doble de grandes. La transformación de un elemento no afecta a su propia geometría local; todas las funciones geométricas (por ejemplo, contains(), update() y todas las funciones de mapeo) siguen operando en coordenadas locales. Para mayor comodidad, `QGraphicsItem` proporciona las funciones ` sceneTransform()`, que devuelve la matriz de transformación total del elemento (incluida su posición y las posiciones y transformaciones de todos los elementos padres), y ` scenePos()`, que devuelve su posición en coordenadas de escena. Para restablecer la matriz de un elemento, llama a ` resetTransform()`.

Ciertas operaciones de transformación producen un resultado diferente dependiendo del orden en que se apliquen. Por ejemplo, si escalas un elemento y luego lo transformas, y a continuación lo giras, es posible que obtengas un resultado diferente al que se obtendría si se hubiera girado primero. Sin embargo, el orden en el que establezcas las propiedades de transformación en `QGraphicsItem` no afecta a la transformación resultante; `QGraphicsItem` siempre aplica las propiedades en un orden fijo y definido:

Dibujo

QGraphicsView invoca la función paint() para pintar el contenido del elemento. El elemento no tiene fondo ni relleno predeterminado propio; lo que haya detrás del elemento se verá a través de todas las áreas que no se pinten explícitamente en esta función. Se puede llamar a ` update()` para programar un repintado, pasando opcionalmente el rectángulo que necesita ser repintado. Dependiendo de si el elemento está visible o no en una vista, el elemento puede ser repintado o no; no existe un equivalente a ` QWidget::repaint()` en `QGraphicsItem`.

Los elementos son dibujados por la vista, comenzando por los elementos padres y pasando luego a los hijos, en orden de apilamiento ascendente. Se puede establecer el orden de apilamiento de un elemento llamando a ` setZValue()` y comprobarlo llamando a ` zValue()`, donde los elementos con valores z bajos se dibujan antes que los que tienen valores z altos. El orden de apilamiento se aplica a los elementos hermanos; los padres siempre se dibujan antes que sus hijos.

Ordenación

Todos los elementos se dibujan en un orden definido y estable, y este mismo orden determina qué elementos recibirán primero la entrada del ratón al hacer clic en la escena. Normalmente no hay que preocuparse por la ordenación, ya que los elementos siguen un «orden natural», acorde con la estructura lógica de la escena.

Los elementos hijos de un elemento se apilan encima del padre, y los elementos hermanos se apilan por orden de inserción (es decir, en el mismo orden en que se añadieron a la escena o al mismo padre). Si añades el elemento A y, a continuación, el B, este último quedará encima del A. Si después añades el C, el orden de apilamiento de los elementos será A, luego B y, por último, C.

Robot con nodos y extremidades numerados

Este ejemplo muestra el orden de apilamiento de todas las extremidades del robot del ejemplo «Robot de arrastrar y soltar ». El torso es el elemento raíz (todos los demás elementos son hijos o descendientes del torso), por lo que se dibuja primero. A continuación, se dibuja la cabeza, ya que es el primer elemento de la lista de hijos del torso. Después se dibuja el brazo superior izquierdo. Como el antebrazo es un hijo del brazo superior, a continuación se dibuja el antebrazo, seguido del siguiente hermano del brazo superior, que es el brazo superior derecho, y así sucesivamente.

Para usuarios avanzados, existen formas de modificar el orden en que se clasifican los elementos:

  • Puedes llamar a ` setZValue()` en un elemento para apilarlo explícitamente encima o debajo de otros elementos hermanos. El valor Z predeterminado de un elemento es 0. Los elementos con el mismo valor Z se apilan por orden de inserción.
  • Puedes llamar a ` stackBefore()` para reordenar la lista de hijos. Esto modificará directamente el orden de inserción.
  • Puedes establecer el indicador ` ItemStacksBehindParent ` para apilar un elemento hijo detrás de su padre.

El orden de apilamiento de dos elementos hermanos también se aplica a los hijos y a los elementos descendientes de cada uno de ellos. Así pues, si un elemento se encuentra encima de otro, todos sus hijos también estarán encima de todos los hijos del otro elemento.

Eventos

QGraphicsItem recibe eventos de QGraphicsScene a través de la función virtual sceneEvent(). Esta función distribuye los eventos más comunes a un conjunto de controladores de eventos de conveniencia:

Puedes filtrar eventos de cualquier otro elemento instalando filtros de eventos. Esta funcionalidad es independiente de los filtros de eventos habituales de Qt XML (véase QObject::installEventFilter()), que solo funcionan en subclases de QObject. Tras instalar tu elemento como filtro de eventos para otro elemento llamando a installSceneEventFilter(), los eventos filtrados serán recibidos por la función virtual sceneEventFilter(). Puedes eliminar los filtros de eventos de un elemento llamando a removeSceneEventFilter().

Datos personalizados

A veces resulta útil registrar datos personalizados en un elemento, ya sea un elemento personalizado o uno estándar. Puedes llamar a ` setData()` en cualquier elemento para almacenar datos en él utilizando un par clave-valor (siendo la clave un número entero y el valor un ` QVariant`). Para obtener datos personalizados de un elemento, llama a ` data()`. Esta funcionalidad no tiene nada que ver con Qt en sí; se proporciona para comodidad del usuario.

Véase también QGraphicsScene, QGraphicsView y Graphics View Framework.

Documentación sobre los tipos de miembros

enum QGraphicsItem::CacheMode

Esta enumeración describe los modos de caché de ` QGraphicsItem`. El almacenamiento en caché se utiliza para acelerar el renderizado mediante la asignación y el renderizado en un búfer de píxeles fuera de pantalla, que puede reutilizarse cuando sea necesario volver a dibujar el elemento. En algunos dispositivos de pintura, la caché se almacena directamente en la memoria gráfica, lo que agiliza considerablemente el renderizado.

ConstanteValorDescripción
QGraphicsItem::NoCache0El valor predeterminado; se desactiva todo el almacenamiento en caché del elemento. Se llama a QGraphicsItem::paint() cada vez que es necesario volver a dibujar el elemento.
QGraphicsItem::ItemCoordinateCache1El almacenamiento en caché está habilitado para el sistema de coordenadas lógico (local) del elemento. QGraphicsItem crea un búfer de píxeles fuera de pantalla con un tamaño y una resolución configurables que se pueden pasar a QGraphicsItem::setCacheMode(). La calidad del renderizado suele verse reducida, dependiendo de la resolución de la caché y de la transformación del elemento. La primera vez que se vuelve a dibujar el elemento, este se renderiza en la caché, que luego se reutiliza para cada exposición posterior. La caché también se reutiliza cuando se transforma el elemento. Para ajustar la resolución de la caché, puede volver a llamar a setCacheMode().
QGraphicsItem::DeviceCoordinateCache2El almacenamiento en caché se habilita a nivel del dispositivo de dibujo, en coordenadas del dispositivo. Este modo está pensado para elementos que pueden moverse, pero que no se rotan, escalan ni deforman. Si el elemento se transforma directa o indirectamente, la caché se regenerará automáticamente. A diferencia de `ItemCoordinateCacheMode`, `DeviceCoordinateCache` siempre se renderiza con la máxima calidad.

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

enum QGraphicsItem::GraphicsItemChange

Esta enumeración describe los cambios de estado que notifica la función QGraphicsItem::itemChange(). Las notificaciones se envían a medida que cambia el estado y, en algunos casos, se pueden realizar ajustes (consulta la documentación de cada cambio para obtener más detalles).

Nota: Hay que tener cuidado al llamar a funciones del propio ` QGraphicsItem ` dentro de ` itemChange()`, ya que ciertas llamadas a funciones pueden provocar una recursión no deseada. Por ejemplo, no se puede llamar a ` setPos()` en ` itemChange()` tras una notificación de `ItemPositionChange`, ya que la función ` setPos()` volverá a llamar a ` itemChange` (`ItemPositionChange`). En su lugar, se puede devolver la nueva posición ajustada desde ` itemChange()`.

ConstanteValorDescripción
QGraphicsItem::ItemEnabledChange3El estado de activación del elemento cambia. Si el elemento está actualmente activado, pasará a estar desactivado, y viceversa. El argumento «value» es el nuevo estado de activación (es decir, «true» o «false»). No llames a setEnabled() en itemChange() cuando se envíe esta notificación. En su lugar, puedes devolver el nuevo estado desde itemChange().
QGraphicsItem::ItemEnabledHasChanged13El estado de activación del elemento ha cambiado. El argumento «value» es el nuevo estado de activación (es decir, «true» o «false»). No llames a ` setEnabled()` dentro de ` itemChange()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemPositionChange0La posición del elemento cambia. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y cuando la posición local del elemento cambia con respecto a su elemento padre (es decir, como resultado de llamar a setPos() o moveBy()). El argumento «value» es la nueva posición (es decir, un QPointF). Puedes llamar a ` pos()` para obtener la posición original. No llames a ` setPos()` ni a ` moveBy()` en ` itemChange()`, ya que se envía esta notificación; en su lugar, puedes devolver la nueva posición ajustada desde ` itemChange()`. Tras esta notificación, ` QGraphicsItem ` envía inmediatamente la notificación `ItemPositionHasChanged` si la posición ha cambiado.
QGraphicsItem::ItemPositionHasChanged9La posición del elemento ha cambiado. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y después de que la posición local del elemento, relativa a su padre, haya cambiado. El argumento «value» es la nueva posición (la misma que en pos()), y QGraphicsItem ignora el valor devuelto por esta notificación (es decir, es una notificación de solo lectura).
QGraphicsItem::ItemTransformChange8La matriz de transformación del elemento cambia. Esta notificación se envía si la opción « ItemSendsGeometryChanges » está activada y cuando cambia la matriz de transformación local del elemento (es decir, como resultado de llamar a ` setTransform()`). El argumento «value» es la nueva matriz (es decir, un ` QTransform`); para obtener la matriz anterior, llame a ` transform()`. No llames a setTransform() ni establezcas ninguna de las propiedades de transformación en itemChange(), ya que se envía esta notificación; en su lugar, puedes devolver la nueva matriz desde itemChange(). Esta notificación no se envía si modificas las propiedades de transformación.
QGraphicsItem::ItemTransformHasChanged10La matriz de transformación del elemento ha cambiado, ya sea porque se ha llamado a setTransform o porque se ha modificado una de las propiedades de transformación. Esta notificación se envía si el indicador ItemSendsGeometryChanges está activado y después de que la matriz de transformación local del elemento haya cambiado. El argumento «value» es la nueva matriz (igual que en transform()), y QGraphicsItem ignora el valor de retorno de esta notificación (es decir, es una notificación de solo lectura).
QGraphicsItem::ItemRotationChange28La propiedad de rotación del elemento cambia. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y cuando cambia la propiedad de rotación del elemento (es decir, como resultado de llamar a setRotation()). El argumento «value» es la nueva rotación (es decir, un doble); para obtener la rotación anterior, llama a rotation(). No llames a setRotation() en itemChange(), ya que se envía esta notificación; en su lugar, puedes devolver la nueva rotación desde itemChange().
QGraphicsItem::ItemRotationHasChanged29La propiedad de rotación del elemento ha cambiado. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y después de que la propiedad de rotación del elemento haya cambiado. El argumento «value» es la nueva rotación (es decir, un valor de tipo «double»), y QGraphicsItem ignora el valor de retorno de esta notificación (es decir, es una notificación de solo lectura). No llames a ` setRotation()` en ` itemChange()`, ya que esta notificación se envía.
QGraphicsItem::ItemScaleChange30La propiedad «scale» del elemento cambia. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y cuando cambia la propiedad «scale» del elemento (es decir, como resultado de llamar a ` setScale()`). El argumento «value» es la nueva escala (es decir, un valor de tipo double); para obtener la escala anterior, llama a ` scale()`. No llames a setScale() en itemChange(), ya que esta notificación ya se ha enviado; en su lugar, puedes devolver la nueva escala desde itemChange().
QGraphicsItem::ItemScaleHasChanged31La propiedad de escala del elemento ha cambiado. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y después de que la propiedad de escala del elemento haya cambiado. El argumento «value» es la nueva escala (es decir, un valor de tipo «double»), y QGraphicsItem ignora el valor de retorno de esta notificación (es decir, es una notificación de solo lectura). No llames a ` setScale()` en ` itemChange()`, ya que esta notificación se envía.
QGraphicsItem::ItemTransformOriginPointChange32La propiedad «punto de origen de la transformación» del elemento cambia. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y cuando cambia la propiedad «punto de origen de la transformación» del elemento (es decir, como resultado de llamar a ` setTransformOriginPoint()`). El argumento «value» es el nuevo punto de origen (es decir, un ` QPointF`); para obtener el punto de origen anterior, llama a ` transformOriginPoint()`. No llames a ` setTransformOriginPoint()` en ` itemChange()` cuando se envíe esta notificación; en su lugar, puedes devolver el nuevo punto de origen de la transformación desde ` itemChange()`.
QGraphicsItem::ItemTransformOriginPointHasChanged33La propiedad del punto de origen de la transformación del elemento ha cambiado. Esta notificación se envía si el indicador « ItemSendsGeometryChanges » está activado y después de que la propiedad del punto de origen de la transformación del elemento haya cambiado. El argumento «value» es el nuevo punto de origen (es decir, un ` QPointF`), y « QGraphicsItem » ignora el valor de retorno de esta notificación (es decir, es una notificación de solo lectura). No llames a ` setTransformOriginPoint()` dentro de ` itemChange()`, ya que se envía esta notificación.
QGraphicsItem::ItemSelectedChange4El estado de selección del elemento cambia. Si el elemento está seleccionado actualmente, dejará de estarlo, y viceversa. El argumento «value» es el nuevo estado de selección (es decir, «true» o «false»). No llames a setSelected() en itemChange() cuando se envíe esta notificación; en su lugar, puedes devolver el nuevo estado de selección desde itemChange().
QGraphicsItem::ItemSelectedHasChanged14El estado de selección del elemento ha cambiado. El argumento «value» es el nuevo estado de selección (es decir, «true» o «false»). No llames a ` setSelected()` dentro de ` itemChange()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemVisibleChange2El estado de visibilidad del elemento cambia. Si el elemento está visible en ese momento, pasará a estar oculto, y viceversa. El argumento «value» es el nuevo estado de visibilidad (es decir, «true» o «false»). No llames a ` setVisible()` dentro de ` itemChange()` cuando se envíe esta notificación; en su lugar, puedes devolver el nuevo estado de visibilidad desde ` itemChange()`.
QGraphicsItem::ItemVisibleHasChanged12El estado de visibilidad del elemento ha cambiado. El argumento «value» es el nuevo estado de visibilidad (es decir, «true» o «false»). No llames a ` setVisible()` dentro de ` itemChange()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemParentChange5El elemento padre del elemento cambia. El argumento «value» es el nuevo elemento padre (es decir, un puntero a « QGraphicsItem »). No llames a « setParentItem()» dentro de « itemChange()» cuando se envíe esta notificación; en su lugar, puedes devolver el nuevo elemento padre desde « itemChange()».
QGraphicsItem::ItemParentHasChanged15El elemento padre del elemento ha cambiado. El argumento «value» es el nuevo elemento padre (es decir, un puntero a un ` QGraphicsItem`). No llames a ` setParentItem()` en ` itemChange()` cuando se envíe esta notificación. El valor de retorno se ignora.
QGraphicsItem::ItemChildAddedChange6Se ha añadido un elemento secundario a este elemento. El argumento «value» es el nuevo elemento secundario (es decir, un puntero a QGraphicsItem ). No pases este elemento a la función ` setParentItem()` de ningún otro elemento, ya que se envía esta notificación. El valor de retorno no se utiliza; no puedes modificar nada en esta notificación. Ten en cuenta que es posible que el nuevo elemento secundario no esté completamente construido cuando se envía esta notificación; llamar a funciones virtuales puras en el elemento secundario puede provocar un fallo del sistema.
QGraphicsItem::ItemChildRemovedChange7Se elimina un elemento secundario de este elemento. El argumento «value» es el elemento secundario que está a punto de ser eliminado (es decir, un puntero QGraphicsItem ). El valor de retorno no se utiliza; no se puede modificar nada en esta notificación.
QGraphicsItem::ItemSceneChange11El elemento se traslada a una nueva escena. Esta notificación también se envía cuando el elemento se añade a su escena inicial y cuando se elimina. El argumento ` scene()` del elemento es la escena anterior, o ` nullptr ` si el elemento aún no se ha añadido a ninguna escena. El argumento «value» es la nueva escena (es decir, un puntero QGraphicsScene ), o nullptr si el elemento se elimina de una escena. No anules este cambio pasando este elemento a ` QGraphicsScene::addItem()` mientras se envía esta notificación; en su lugar, puedes devolver la nueva escena desde ` itemChange()`. Utiliza esta función con precaución; oponerte a un cambio de escena puede provocar rápidamente una recursión no deseada.
QGraphicsItem::ItemSceneHasChanged16La escena del elemento ha cambiado. El método ` scene()` del elemento es la nueva escena. Esta notificación también se envía cuando el elemento se añade a su escena inicial y cuando se elimina. El argumento `value` es la nueva escena (es decir, un puntero a un ` QGraphicsScene`). No llames a `setScene()` en ` itemChange()` mientras se envía esta notificación. El valor de retorno se ignora.
QGraphicsItem::ItemCursorChange17El cursor del elemento cambia. El argumento «value» es el nuevo cursor (es decir, un ` QCursor`). No llames a ` setCursor()` en ` itemChange()` mientras se envía esta notificación. En su lugar, puedes devolver un nuevo cursor desde ` itemChange()`.
QGraphicsItem::ItemCursorHasChanged18El cursor del elemento ha cambiado. El argumento «value» es el nuevo cursor (es decir, un ` QCursor`). No llames a ` setCursor()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemToolTipChange19La información sobre herramientas del elemento cambia. El argumento «value» es la nueva información sobre herramientas (es decir, un ` QToolTip`). No llames a ` setToolTip()` en ` itemChange()` cuando se envíe esta notificación. En su lugar, puedes devolver una nueva información sobre herramientas desde ` itemChange()`.
QGraphicsItem::ItemToolTipHasChanged20La información sobre herramientas del elemento ha cambiado. El argumento «value» es la nueva información sobre herramientas (es decir, un ` QToolTip`). No llames a ` setToolTip()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemFlagsChange21Los indicadores del elemento cambian. El argumento «value» es el nuevo indicador (es decir, un «quint32»). No llames a ` setFlags()` en ` itemChange()` cuando se envíe esta notificación. En su lugar, puedes devolver los nuevos indicadores mediante ` itemChange()`.
QGraphicsItem::ItemFlagsHaveChanged22Los indicadores del elemento han cambiado. El argumento «value» es el nuevo valor de los indicadores (es decir, un quint32). No llames a ` setFlags()` dentro de ` itemChange()`, ya que se envía esta notificación. El valor de retorno se ignora.
QGraphicsItem::ItemZValueChange23El valor Z del elemento cambia. El argumento `value` es el nuevo valor Z (es decir, un `double`). No llames a ` setZValue()` en ` itemChange()` cuando se envíe esta notificación. En su lugar, puedes devolver un nuevo valor Z desde ` itemChange()`.
QGraphicsItem::ItemZValueHasChanged24El valor Z del elemento ha cambiado. El argumento «value» es el nuevo valor Z (es decir, un doble). No llames a ` setZValue()` cuando se envíe esta notificación. El valor devuelto se ignora.
QGraphicsItem::ItemOpacityChange25La opacidad del elemento cambia. El argumento «value» es la nueva opacidad (es decir, un valor de tipo double). No llames a setOpacity() en itemChange() cuando se envíe esta notificación. En su lugar, puedes devolver una nueva opacidad desde itemChange().
QGraphicsItem::ItemOpacityHasChanged26La opacidad del elemento ha cambiado. El argumento «value» es la nueva opacidad (es decir, un valor de tipo «double»). No llames a ` setOpacity()` cuando se envíe esta notificación. El valor de retorno se ignora.
QGraphicsItem::ItemScenePositionHasChanged27La posición del elemento en la escena ha cambiado. Esta notificación se envía si el indicador « ItemSendsScenePositionChanges » está activado y después de que la posición del elemento en la escena haya cambiado (es decir, ha cambiado la posición o la transformación del propio elemento o la posición o la transformación de cualquier antecesor). El argumento «value» es la nueva posición en la escena (igual que en « scenePos()»), y « QGraphicsItem » ignora el valor de retorno de esta notificación (es decir, es una notificación de solo lectura).

enum QGraphicsItem::GraphicsItemFlag
flags QGraphicsItem::GraphicsItemFlags

Esta enumeración describe los distintos indicadores que puedes activar en un elemento para habilitar o deshabilitar diferentes funciones en su comportamiento.

Todos los indicadores están desactivados por defecto.

ConstanteValorDescripción
QGraphicsItem::ItemIsMovable0x1El elemento admite el desplazamiento interactivo con el ratón. Al hacer clic en el elemento y arrastrarlo, este se desplazará junto con el cursor del ratón. Si el elemento tiene elementos secundarios, estos también se moverán. Si el elemento forma parte de una selección, todos los elementos seleccionados también se moverán. Esta función se proporciona como una comodidad a través de la implementación básica de los controladores de eventos del ratón de QGraphicsItem.
QGraphicsItem::ItemIsSelectable0x2El elemento admite la selección. Al habilitar esta función, se permitirá que ` setSelected()` active o desactive la selección del elemento. También permitirá que el elemento se seleccione automáticamente al llamar a ` QGraphicsScene::setSelectionArea()`, al hacer clic en un elemento o al utilizar la selección de «banda elástica» en ` QGraphicsView`.
QGraphicsItem::ItemIsFocusable0x4El elemento admite el foco de entrada del teclado (es decir, es un elemento de entrada). Al habilitar este indicador, el elemento podrá aceptar el foco, lo que a su vez permite que se envíen eventos de teclas a QGraphicsItem::keyPressEvent() y QGraphicsItem::keyReleaseEvent().
QGraphicsItem::ItemClipsToShape0x8El elemento se recorta a su propia forma. El elemento no puede dibujar ni recibir eventos de ratón, tableta, arrastrar y soltar o de paso del cursor fuera de su forma. Está desactivado por defecto. Este comportamiento se aplica mediante QGraphicsView::drawItems() o QGraphicsScene::drawItems(). Este indicador se introdujo en Qt 4.3.
QGraphicsItem::ItemClipsChildrenToShape0x10El elemento recorta el dibujo de todos sus descendientes a su propia forma. Los elementos que sean hijos directos o indirectos de este elemento no pueden dibujar fuera de la forma de este. Por defecto, este indicador está desactivado; los hijos pueden dibujar en cualquier lugar. Este comportamiento se aplica mediante QGraphicsView::drawItems() o QGraphicsScene::drawItems(). Este indicador se introdujo en Qt 4.3.

Nota: Este indicador es similar a `ItemContainsChildrenInShape`, pero además impone la contención recortando a los hijos.

QGraphicsItem::ItemIgnoresTransformations0x20El elemento ignora las transformaciones heredadas (es decir, su posición sigue anclada a su padre, pero se ignoran las transformaciones de rotación, zoom o sesgo del padre o de la vista). Este indicador resulta útil para mantener los elementos de etiqueta de texto en posición horizontal y sin escalar, de modo que sigan siendo legibles si se transforma la vista. Cuando se activa, la geometría de la vista del elemento y la geometría de la escena se mantendrán por separado. Debes llamar a ` deviceTransform()` para mapear coordenadas y detectar colisiones en la vista. Por defecto, este indicador está desactivado. Este indicador se introdujo en Qt 4.3.

Nota: Aunque esta opción esté activada, se puede seguir escalando el propio elemento, y esa transformación de escala influirá en los elementos hijos del mismo.

QGraphicsItem::ItemIgnoresParentOpacity0x40El elemento ignora la opacidad de su padre. La opacidad efectiva del elemento es la misma que la suya propia; no se combina con la opacidad del padre. Este indicador permite que el elemento mantenga su opacidad absoluta incluso si el padre es semitransparente. Este indicador se introdujo en Qt 4.5.
QGraphicsItem::ItemDoesntPropagateOpacityToChildren0x80El elemento no propaga su opacidad a sus elementos hijos. Este indicador permite crear un elemento semitransparente que no afecta a la opacidad de sus elementos hijos. Este indicador se introdujo en Qt 4.5.
QGraphicsItem::ItemStacksBehindParent0x100El elemento se apila detrás de su elemento padre. Por defecto, los elementos hijos se apilan encima del elemento padre. Sin embargo, al activar este indicador, el elemento hijo se apilará detrás de él. Este indicador resulta útil para efectos de sombra proyectada y para objetos decorativos que siguen la geometría del elemento padre sin dibujarse encima de él. Este indicador se introdujo en Qt 4.5.
QGraphicsItem::ItemUsesExtendedStyleOption0x200El elemento utiliza ` exposedRect ` en ` QStyleOptionGraphicsItem`. Por defecto, ` exposedRect ` se inicializa con ` boundingRect()` del elemento. Puedes activar este indicador para configurar las opciones de estilo con valores más precisos. Utiliza ` QStyleOptionGraphicsItem::levelOfDetailFromTransform()` si necesitas un valor más alto. Este indicador se introdujo en Qt 4.6.
QGraphicsItem::ItemHasNoContents0x400El elemento no dibuja nada (es decir, llamar a ` paint()` en el elemento no tiene ningún efecto). Debes activar esta bandera en los elementos que no necesiten ser dibujados para garantizar que Graphics View evite preparativos de dibujo innecesarios. Esta bandera se introdujo en Qt 4.6.
QGraphicsItem::ItemSendsGeometryChanges0x800El elemento habilita las notificaciones de ` itemChange()` para ` ItemPositionChange`, ` ItemPositionHasChanged`, ` ItemTransformChange`, ` ItemTransformHasChanged`, ` ItemRotationChange`, ` ItemRotationHasChanged`, ` ItemScaleChange`, ` ItemScaleHasChanged`, ` ItemTransformOriginPointChange` y ` ItemTransformOriginPointHasChanged`. Por motivos de rendimiento, estas notificaciones están deshabilitadas por defecto. Debes habilitar este indicador para recibir notificaciones sobre cambios de posición y transformación. Este indicador se introdujo en Qt 4.6.
QGraphicsItem::ItemAcceptsInputMethod0x1000El elemento admite los métodos de entrada que se utilizan habitualmente en los idiomas asiáticos. Esta opción se introdujo en Qt 4.6.
QGraphicsItem::ItemNegativeZStacksBehindParent0x2000El elemento se apila automáticamente detrás de su elemento padre si su valor z es negativo. Esta opción permite que setZValue() active o desactive ItemStacksBehindParent. Esta opción se introdujo en Qt 4.6.
QGraphicsItem::ItemIsPanel0x4000El elemento es un panel. Un panel proporciona la gestión de la activación y del foco en su contenido. Solo puede haber un panel activo a la vez (véase QGraphicsItem::isActive()). Cuando ningún panel está activo, QGraphicsScene activa todos los elementos que no sean paneles. Los elementos de ventana (es decir, aquellos para los que QGraphicsItem::isWindow() devuelve true) son paneles. Este indicador se introdujo en Qt 4.6.
QGraphicsItem::ItemSendsScenePositionChanges0x10000El elemento habilita las notificaciones de itemChange() para ItemScenePositionHasChanged. Por motivos de rendimiento, estas notificaciones están desactivadas por defecto. Debes habilitar este indicador para recibir notificaciones sobre los cambios de posición de la escena. Este indicador se introdujo en Qt 4.6.
QGraphicsItem::ItemContainsChildrenInShape0x80000Este indicador señala que todos los elementos hijos directos o indirectos del elemento solo se dibujan dentro de la forma del elemento. A diferencia de `ItemClipsChildrenToShape`, esta restricción no se aplica de forma obligatoria. Establece ItemContainsChildrenInShape cuando te asegures manualmente de que el dibujo se limita a la forma del elemento y quieras evitar el coste asociado a la aplicación del recorte. Establecer este indicador permite un dibujo y una detección de colisiones más eficientes. El indicador está desactivado por defecto.

Nota: Si se activan tanto esta opción como ItemClipsChildrenToShape, se aplicará el recorte. Esto equivale a activar únicamente ItemClipsChildrenToShape.

Este indicador se introdujo en Qt 5.4.

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

enum QGraphicsItem::PanelModality

Esta enumeración especifica el comportamiento de un panel modal. Un panel modal es aquel que bloquea la entrada a otros paneles. Ten en cuenta que los elementos que son hijos de un panel modal no quedan bloqueados.

Los valores son:

ConstanteValorDescripción
QGraphicsItem::NonModal0El panel no es modal y no bloquea la entrada a otros paneles. Este es el valor por defecto para los paneles.
QGraphicsItem::PanelModal1El panel es modal respecto a una jerarquía de un único elemento y bloquea la entrada al panel padre, a todos los paneles bisabuelos y a todos los paneles hermanos de sus paneles padre y bisabuelos.
QGraphicsItem::SceneModal2La ventana es modal para toda la escena y bloquea la entrada a todos los paneles.

Véase también QGraphicsItem::setPanelModality(), QGraphicsItem::panelModality() y QGraphicsItem::ItemIsPanel.

[anonymous] enum

El valor devuelto por la función virtual ` type()` en las clases de elementos gráficos estándar de Qt. Todas estas clases de elementos gráficos estándar de Qt están asociadas a un valor único para `Type`; por ejemplo, el valor devuelto por ` QGraphicsPathItem::type()` es 2.

ConstanteValorDescripción
QGraphicsItem::Type1
class QGraphicsPathItem : public QAbstractGraphicsShapeItem
{
 public:
  enum { Type = 2 };
    int type() const override { return Type; }
  //...
};
QGraphicsItem::UserType65536El valor más bajo devuelto por la función virtual type() para las subclases personalizadas de QGraphicsItem.
class Item : public QGraphicsItem
{
public:
   enum { Type = UserType + 1 };

   int type() const override
   {
       // Enable the use of qgraphicsitem_cast with this item.
       return Type;
   }
   //...
};

Documentación de funciones de miembro

[explicit] QGraphicsItem::QGraphicsItem(QGraphicsItem *parent = nullptr)

Crea un QGraphicsItem con el elemento parent especificado. No modifica el objeto padre devuelto por QObject::parent().

Si parent es nullptr, puedes añadir el elemento a una escena llamando a QGraphicsScene::addItem(). El elemento pasará entonces a ser un elemento de nivel superior.

Véase también QGraphicsScene::addItem() y setParentItem().

[virtual noexcept] QGraphicsItem::~QGraphicsItem()

Elimina el objeto « QGraphicsItem » y todos sus elementos secundarios. Si este objeto está asociado actualmente a una escena, se retirará de la escena antes de ser eliminado.

Nota: Es más eficiente eliminar el elemento de la « QGraphicsScene » antes de destruirlo.

bool QGraphicsItem::acceptDrops() const

Devuelve ` true ` si este elemento admite eventos de arrastrar y soltar; en caso contrario, devuelve ` false`. Por defecto, los elementos no admiten eventos de arrastrar y soltar; son transparentes a esta acción.

Véase también setAcceptDrops().

bool QGraphicsItem::acceptHoverEvents() const

Devuelve « true » si un elemento admite eventos de desplazamiento del cursor (QGraphicsSceneHoverEvent); en caso contrario, devuelve « false ». Por defecto, los elementos no admiten eventos de desplazamiento del cursor.

Véase también setAcceptHoverEvents() y setAcceptedMouseButtons().

bool QGraphicsItem::acceptTouchEvents() const

Devuelve ` true ` si un elemento admite ` touch events`; en caso contrario, devuelve ` false`. Por defecto, los elementos no admiten eventos táctiles.

Véase también setAcceptTouchEvents().

Qt::MouseButtons QGraphicsItem::acceptedMouseButtons() const

Devuelve los botones del ratón para los que este elemento acepta eventos de ratón. Por defecto, se aceptan todos los botones del ratón.

Si un elemento acepta un botón del ratón, se convertirá en el elemento captador del ratón cuando se envíe un evento de pulsación de ratón para ese botón. Sin embargo, si el elemento no acepta el botón, QGraphicsScene reenviará los eventos del ratón al primer elemento situado debajo de él que sí lo acepte.

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

[virtual] void QGraphicsItem::advance(int phase)

La ranura ` QGraphicsScene::advance()` llama a esta función virtual dos veces para todos los elementos. En la primera fase, se llama a todos los elementos con ` phase == 0`, lo que indica que los elementos de la escena están a punto de avanzar; a continuación, se llama a todos los elementos con ` phase == 1`. Reimplementa esta función para actualizar tu elemento si necesitas una animación sencilla controlada por la escena.

La implementación por defecto no hace nada.

Esta función está pensada para animaciones. Una alternativa es heredar múltiplemente de ` QObject ` y ` QGraphicsItem ` y utilizar el Marco de Animación.

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

[pure virtual] QRectF QGraphicsItem::boundingRect() const

Esta función virtual pura define los límites exteriores del elemento como un rectángulo; todo el dibujo debe limitarse al interior del rectángulo delimitador del elemento. La función « QGraphicsView » utiliza esto para determinar si es necesario volver a dibujar el elemento.

Aunque la forma del elemento puede ser arbitraria, el rectángulo delimitador es siempre rectangular y no se ve afectado por la transformación de los elementos.

Si deseas cambiar el rectángulo delimitador del elemento, primero debes llamar a prepareGeometryChange(). Esto notifica a la escena del cambio inminente, de modo que pueda actualizar su índice de geometría de elementos; de lo contrario, la escena no tendrá constancia de la nueva geometría del elemento y los resultados serán indefinidos (por lo general, quedarán artefactos de renderizado en la vista).

Reimplementa esta función para que ` QGraphicsView ` determine qué partes del widget, si las hay, deben volver a dibujarse.

Nota: En el caso de las formas que dibujan un contorno o trazo, es importante incluir la mitad del ancho del trazo en el rectángulo delimitador. Sin embargo, no es necesario compensar el suavizado.

Ejemplo:

QRectF CircleItem::boundingRect() const
{
    qreal penWidth = 1;
    return QRectF(-radius - penWidth / 2, -radius - penWidth / 2,
                  diameter + penWidth, diameter + penWidth);
}

Véase también boundingRegion(), shape(), contains(), El sistema de coordenadas de la vista gráfica y prepareGeometryChange().

QRegion QGraphicsItem::boundingRegion(const QTransform &itemToDeviceTransform) const

Devuelve la región delimitadora de este elemento. El espacio de coordenadas de la región devuelta depende de ` itemToDeviceTransform`. Si se pasa como parámetro un ` QTransform ` de identidad, esta función devolverá una región de coordenadas locales.

La región delimitadora describe un contorno aproximado del contenido visual del elemento. Aunque su cálculo resulta costoso, es más precisa que boundingRect(), y puede ayudar a evitar un redibujado innecesario cuando se actualiza un elemento. Esto resulta especialmente eficaz para elementos delgados (por ejemplo, líneas o polígonos simples). Puedes ajustar la granularidad de la región delimitadora llamando a setBoundingRegionGranularity(). La granularidad por defecto es 0; en este caso, la región delimitadora del elemento es la misma que su rectángulo delimitador.

itemToDeviceTransform es la transformación de las coordenadas del elemento a las coordenadas del dispositivo. Si deseas que esta función devuelva un ` QRegion ` en coordenadas de escena, puedes pasar ` sceneTransform()` como argumento.

Véase también boundingRegionGranularity().

qreal QGraphicsItem::boundingRegionGranularity() const

Devuelve la granularidad de la región delimitadora del elemento; un valor comprendido entre 0 y 1, ambos inclusive. El valor por defecto es 0 (es decir, la granularidad más baja, en la que la región delimitadora se corresponde con el rectángulo delimitador del elemento).

Véase también setBoundingRegionGranularity().

QGraphicsItem::CacheMode QGraphicsItem::cacheMode() const

Devuelve el modo de caché de este elemento. El modo predeterminado es « NoCache » (es decir, la caché está desactivada y todo el dibujo se realiza de forma inmediata).

Véase también setCacheMode().

QList<QGraphicsItem *> QGraphicsItem::childItems() const

Devuelve una lista de los elementos secundarios de este elemento.

Los elementos se ordenan según su orden de apilamiento. Para ello se tienen en cuenta tanto el orden de inserción de los elementos como sus valores Z.

Véase también setParentItem(), zValue() y Sorting.

QRectF QGraphicsItem::childrenBoundingRect() const

Devuelve el rectángulo delimitador de los descendientes de este elemento (es decir, sus hijos, los hijos de estos, etc.) en coordenadas locales. El rectángulo contendrá todos los descendientes una vez que se hayan mapeado a coordenadas locales. Si el elemento no tiene hijos, esta función devuelve un QRectF vacío.

Esto no incluye el rectángulo delimitador del propio elemento; solo devuelve el rectángulo delimitador acumulado de sus descendientes. Si necesitas incluir el rectángulo delimitador de este elemento, puedes añadir boundingRect() a childrenBoundingRect() utilizando QRectF::operator|().

Esta función tiene una complejidad lineal; determina el tamaño del rectángulo delimitador devuelto mediante una iteración por todos los descendientes.

Véase también ` boundingRect()` y ` sceneBoundingRect()`.

void QGraphicsItem::clearFocus()

Retira el foco de entrada del teclado del elemento.

Si tiene el foco, se envía un evento « focus out event » a este elemento para indicarle que está a punto de perderlo.

Solo los elementos que activan el indicador « ItemIsFocusable », o los widgets que establecen una política de foco adecuada, pueden aceptar el foco del teclado.

Véase también ` setFocus()`, ` hasFocus()` y ` QGraphicsWidget::focusPolicy`.

QPainterPath QGraphicsItem::clipPath() const

Devuelve la ruta de recorte de este elemento, o un objeto « QPainterPath » vacío si el elemento no está recortado. La ruta de recorte limita la apariencia y la interacción del elemento (es decir, restringe el área en la que el elemento puede dibujarse y recibir eventos).

Puedes habilitar el recorte estableciendo los indicadores « ItemClipsToShape » o « ItemClipsChildrenToShape ». La ruta de recorte del elemento se calcula mediante la intersección de todas las formas de los antepasados que aplican recorte. Si el elemento establece « ItemClipsToShape », el recorte final se cruza con la propia forma del elemento.

Nota: El recorte supone una pérdida de rendimiento para todos los elementos implicados; por lo general, se debe evitar utilizarlo siempre que sea posible (por ejemplo, si los elementos siempre se dibujan dentro de los límites de ` boundingRect()` o ` shape()`, el recorte no es necesario).

Véanse también isClipped(), shape() y setFlags().

[virtual] bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Devuelve ` true ` si este elemento colisiona con ` other`; en caso contrario, devuelve ` false`.

Se aplica mode a other y, a continuación, la forma resultante o el rectángulo delimitador se compara con la forma de este elemento. El valor por defecto de mode es Qt::IntersectsItemShape; other colisiona con este elemento si se cruza con la forma de este, la contiene o está contenida por ella (véase Qt::ItemSelectionMode para más detalles).

La implementación por defecto se basa en la intersección de formas y llama a shape() en ambos elementos. Dado que la complejidad de la intersección entre formas arbitrarias aumenta en un orden de magnitud cuando las formas son complejas, esta operación puede requerir un tiempo considerable. Tienes la opción de reimplementar esta función en una subclase de ` QGraphicsItem ` para proporcionar un algoritmo personalizado. Esto te permite aprovechar las restricciones naturales de las formas de tus propios elementos, con el fin de mejorar el rendimiento de la detección de colisiones. Por ejemplo, la colisión entre dos elementos perfectamente circulares sin transformar puede determinarse de forma muy eficiente comparando sus posiciones y radios.

Ten en cuenta que, al reimplementar esta función y llamar a shape() o boundingRect() en other, las coordenadas devueltas deben asignarse al sistema de coordenadas de este elemento antes de que pueda producirse cualquier intersección.

Véanse también contains() y shape().

[virtual] bool QGraphicsItem::collidesWithPath(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

Devuelve « true » si este elemento entra en colisión con « path ».

La colisión viene determinada por mode. El valor por defecto de mode es Qt::IntersectsItemShape; path colisiona con este elemento si se cruza con él, lo contiene o está contenido por la forma de este elemento.

Tenga en cuenta que esta función comprueba si la forma del elemento o su rectángulo delimitador (dependiendo de mode) está contenido dentro de path, y no si path está contenido dentro de la forma o del rectángulo delimitador del elemento.

Véanse también collidesWithItem(), contains() y shape().

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

Devuelve una lista de todos los elementos que colisionan con este elemento.

La forma en que se detectan las colisiones se determina aplicando mode a los elementos que se comparan con este elemento; es decir, se comprueba la forma o el rectángulo delimitador de cada elemento con respecto a la forma de este elemento. El valor por defecto de mode es Qt::IntersectsItemShape.

Véase también collidesWithItem().

QGraphicsItem *QGraphicsItem::commonAncestorItem(const QGraphicsItem *other) const

Devuelve el elemento antepasado común más cercano de este elemento y other, o nullptr si other es nullptr, o si no hay ningún antepasado común.

Véase también isAncestorOf().

[virtual] bool QGraphicsItem::contains(const QPointF &point) const

Devuelve ` true ` si este elemento contiene ` point`, que está en coordenadas locales; en caso contrario, devuelve `false`. Se suele llamar desde ` QGraphicsView ` para determinar qué elemento se encuentra bajo el cursor y, por ese motivo, la implementación de esta función debe ser lo más ligera posible.

Por defecto, esta función llama a ` shape()`, pero se puede reimplementar en una subclase para proporcionar una implementación (quizás más eficiente).

Véanse también shape(), boundingRect() y collidesWithPath().

[virtual protected] void QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

Este controlador de eventos se puede reimplementar en una subclase para procesar eventos del menú contextual. El parámetro ` event ` contiene detalles sobre el evento que se va a gestionar.

Si se ignora el evento (por ejemplo, llamando a QEvent::ignore()), event se propagará a cualquier elemento situado debajo de este. Si ningún elemento acepta el evento, la escena lo ignorará y se propagará a la vista.

Es habitual abrir un QMenu en respuesta a la recepción de un evento del menú contextual. Ejemplo:

void CustomItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
{
    QMenu menu;
    QAction *removeAction = menu.addAction("Remove");
    QAction *markAction = menu.addAction("Mark");
    QAction *selectedAction = menu.exec(event->screenPos());
    // ...
}

La implementación predeterminada ignora el evento.

Véase también sceneEvent().

QCursor QGraphicsItem::cursor() const

Devuelve la forma actual del cursor para el elemento. El cursor del ratón adoptará esta forma cuando se sitúe sobre dicho elemento. Consulta la guía « list of predefined cursor objects » para ver una selección de formas útiles.

Es posible que un elemento del editor quiera utilizar un cursor en forma de «I»:

item->setCursor(Qt::IBeamCursor);

Si no se ha establecido ningún cursor, se utiliza el cursor del elemento subyacente.

Véanse también setCursor(), hasCursor(), unsetCursor(), QWidget::cursor y QGuiApplication::overrideCursor().

QVariant QGraphicsItem::data(int key) const

Devuelve los datos personalizados de este elemento para la clave « key » como un objeto « QVariant ».

Los datos personalizados de los elementos son útiles para almacenar propiedades arbitrarias en cualquier elemento. Ejemplo:

static const int ObjectName = 0;

QGraphicsItem *item = scene.itemAt(100, 50, transform);
if (item->data(ObjectName).toString().isEmpty()) {
    if (qgraphicsitem_cast<CustomItem *>(item))
        item->setData(ObjectName, "Custom");
}

Qt no utiliza esta función para almacenar datos; se proporciona únicamente para comodidad del usuario.

Véase también setData().

QTransform QGraphicsItem::deviceTransform(const QTransform &viewportTransform) const

Devuelve la matriz de transformación del dispositivo de este elemento, utilizando « viewportTransform » para realizar la conversión de coordenadas de la escena a las del dispositivo. Esta matriz se puede utilizar para convertir coordenadas y formas geométricas del sistema de coordenadas local de este elemento al sistema de coordenadas de la ventana gráfica (o de cualquier dispositivo). Para convertir coordenadas desde la ventana gráfica, primero debes invertir la matriz devuelta.

Ejemplo:

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.deviceTransform(view->viewportTransform()).map(QPointF(0, 0));
// returns the item's (0, 0) point in view's viewport coordinates

rect.deviceTransform(view->viewportTransform()).inverted().map(QPointF(100, 100));
// returns view's viewport's (100, 100) coordinate in item coordinates

Esta función equivale a combinar la transformación de escena de este elemento con la transformación de la ventana gráfica de la vista, pero además admite el indicador « ItemIgnoresTransformations ». La transformación del dispositivo se puede utilizar para realizar una conversión precisa de coordenadas (y la detección de colisiones) en elementos no transformables.

Véase también transform(), setTransform(), scenePos(), «El sistema de coordenadas de la vista gráfica» y itemTransform().

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

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de «drag enter» para este elemento. Los eventos de «drag enter» se generan cuando el cursor entra en el área del elemento.

Al aceptar el evento (es decir, al llamar a ` QEvent::accept()`), el elemento aceptará eventos de «suelta», además de recibir eventos de «arrastre de desplazamiento» y «salida de arrastre». De lo contrario, el evento se ignorará y se propagará al elemento subyacente. Si se acepta el evento, el elemento recibirá un evento de «arrastre de desplazamiento» antes de que el control vuelva al bucle de eventos.

Una implementación habitual de `dragEnterEvent` acepta o ignora ` event ` en función de los datos MIME asociados en ` event`. Ejemplo:

CustomItem::CustomItem()
{
    setAcceptDrops(true);
    //...
}

void CustomItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    event->setAccepted(event->mimeData()->hasFormat("text/plain"));
}

Los elementos no reciben eventos de arrastrar y soltar de forma predeterminada; para habilitar esta función, llama a ` setAcceptDrops(true)`.

La implementación por defecto no realiza ninguna acción.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de salida de arrastre de este elemento. Los eventos de salida de arrastre se generan cuando el cursor sale del área del elemento. En la mayoría de los casos no será necesario reimplementar esta función, pero puede resultar útil para restablecer el estado del elemento (por ejemplo, el resaltado).

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` en ` event ` no tiene ningún efecto.

Los elementos no reciben eventos de arrastrar y soltar de forma predeterminada; para habilitar esta función, llama a ` setAcceptDrops(true)`.

La implementación predeterminada no realiza ninguna acción.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de arrastre y desplazamiento de este elemento. Los eventos de arrastre y desplazamiento se generan a medida que el cursor se desplaza por el interior del área del elemento. En la mayoría de los casos, no será necesario reimplementar esta función; se utiliza para indicar que solo determinadas partes del elemento pueden aceptar sueltes.

Al llamar a ` QEvent::ignore()` o a ` QEvent::accept()` sobre ` event `, se activa o desactiva la posibilidad de que el elemento acepte sueltes en la posición indicada por el evento. Por defecto, se acepta ` event `, lo que indica que el elemento permite sueltes en la posición especificada.

Los elementos no reciben eventos de arrastrar y soltar de forma predeterminada; para habilitar esta función, llama a setAcceptDrops(true).

La implementación por defecto no realiza ninguna acción.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de suelta para este elemento. Los elementos solo pueden recibir eventos de suelta si se aceptó el último evento de arrastre.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` sobre ` event ` no tiene ningún efecto.

Los elementos no reciben eventos de arrastrar y soltar de forma predeterminada; para habilitar esta función, llama a ` setAcceptDrops(true)`.

La implementación por defecto no realiza ninguna acción.

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

qreal QGraphicsItem::effectiveOpacity() const

Devuelve la opacidad efectiva de este elemento, que oscila entre 0,0 (transparente) y 1,0 (opaco). Este valor es una combinación de la opacidad local de este elemento y de las opacidades de su elemento padre y de sus antepasados. La opacidad efectiva determina cómo se representa el elemento.

Véase también opacity(), setOpacity(), paint(), ItemIgnoresParentOpacity y ItemDoesntPropagateOpacityToChildren.

void QGraphicsItem::ensureVisible(const QRectF &rect = QRectF(), int xmargin = 50, int ymargin = 50)

Si este elemento forma parte de una escena que se visualiza mediante un « QGraphicsView », esta función de conveniencia intentará desplazar la vista para garantizar que « rect » quede visible dentro de la ventana de visualización de la vista. Si « rect » es un rectángulo nulo (valor por defecto), « QGraphicsItem » adoptará por defecto el rectángulo delimitador del elemento. « xmargin » y « ymargin » son el número de píxeles que la vista debe utilizar para los márgenes.

Si no se puede acceder al rectángulo especificado, el contenido se desplaza hasta la posición válida más cercana.

Si este elemento no es visualizado por un ` QGraphicsView`, esta función no realiza ninguna acción.

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

void QGraphicsItem::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)

Esta función de conveniencia equivale a llamar a `ensureVisible(QRectF(x, y, w, h), xmargin, ymargin)`.

bool QGraphicsItem::filtersChildEvents() const

Devuelve « true » si este elemento filtra los eventos secundarios (es decir, todos los eventos destinados a cualquiera de sus elementos secundarios se envían en su lugar a este elemento); en caso contrario, se devuelve «false».

El valor por defecto es false; los eventos secundarios no se filtran.

Véase también setFiltersChildEvents().

QGraphicsItem::GraphicsItemFlags QGraphicsItem::flags() const

Devuelve los indicadores de este elemento. Los indicadores describen qué características configurables del elemento están activadas y cuáles no. Por ejemplo, si los indicadores incluyen « ItemIsFocusable », el elemento puede recibir el foco de entrada.

Por defecto, no hay ningún indicador activado.

Véase también ` setFlags()` y ` setFlag()`.

[virtual protected] void QGraphicsItem::focusInEvent(QFocusEvent *event)

Este controlador de eventos, para el evento event, puede reimplementarse para recibir el foco en los eventos relacionados con este elemento. La implementación predeterminada llama a ensureVisible().

Véase también ` focusOutEvent()`, ` sceneEvent()` y ` setFocus()`.

QGraphicsItem *QGraphicsItem::focusItem() const

Si este elemento, o un elemento secundario o descendiente del mismo, tiene actualmente el foco de entrada, esta función devolverá un puntero a dicho elemento. Si ningún descendiente tiene el foco de entrada, se devuelve « nullptr ».

Véase también hasFocus(), setFocus() y QWidget::focusWidget().

[virtual protected] void QGraphicsItem::focusOutEvent(QFocusEvent *event)

Este controlador de eventos, para el evento event, puede reimplementarse para recibir eventos de pérdida de foco de este elemento. La implementación predeterminada no realiza ninguna acción.

Véase también « focusInEvent()», « sceneEvent()» y « setFocus()».

QGraphicsItem *QGraphicsItem::focusProxy() const

Devuelve el proxy de foco de este elemento, o bien « nullptr » si este elemento no tiene proxy de foco.

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

void QGraphicsItem::grabKeyboard()

Captura la entrada del teclado.

El elemento recibirá todas las entradas del teclado destinadas a la escena hasta que se produzca uno de los siguientes eventos:

  • El elemento se vuelve invisible
  • El elemento se elimina de la escena
  • Se elimina el elemento
  • El elemento llama a ` ungrabKeyboard()`
  • Otro elemento llama a `grabKeyboard()`; el elemento recuperará el control del teclado cuando el otro elemento llame a ` ungrabKeyboard()`.

Cuando un elemento obtiene el control del teclado, recibe un evento « QEvent::GrabKeyboard ». Cuando lo pierde, recibe un evento « QEvent::UngrabKeyboard ». Estos eventos pueden utilizarse para detectar cuándo tu elemento obtiene o pierde el control del teclado por medios distintos a la obtención del foco de entrada.

Casi nunca es necesario capturar explícitamente el teclado en Qt, ya que Qt lo captura y lo libera de forma inteligente. En concreto, Qt captura el teclado cuando el elemento obtiene el foco de entrada y lo libera cuando el elemento pierde el foco de entrada o cuando se oculta.

Ten en cuenta que solo los elementos visibles pueden capturar la entrada del teclado. Llamar a `grabKeyboard()` en un elemento invisible no tiene ningún efecto.

Los eventos del teclado no se ven afectados.

Véase también ungrabKeyboard(), grabMouse() y setFocus().

void QGraphicsItem::grabMouse()

Captura la entrada del ratón.

Este elemento recibirá todos los eventos del ratón de la escena hasta que se produzca cualquiera de los siguientes eventos:

  • El elemento se vuelve invisible
  • El elemento se elimina de la escena
  • Se elimina el elemento
  • El elemento llama a ` ungrabMouse()`
  • Otro elemento llama a `grabMouse();` el elemento recuperará el control del ratón cuando el otro elemento llame a ` ungrabMouse()`.

Cuando un elemento obtiene el control del ratón, recibe un evento « QEvent::GrabMouse ». Cuando pierde el control del ratón, recibe un evento « QEvent::UngrabMouse ». Estos eventos se pueden utilizar para detectar cuándo tu elemento obtiene o pierde el control del ratón por medios distintos a la recepción de eventos de botones del ratón.

Casi nunca es necesario capturar el ratón de forma explícita en Qt, ya que Qt lo captura y lo libera de forma adecuada. En concreto, Qt captura el ratón cuando se pulsa un botón del ratón y lo mantiene capturado hasta que se suelta el último botón del ratón. Además, los widgets Qt::Popup llaman implícitamente a grabMouse() cuando se muestran y a ungrabMouse() cuando se ocultan.

Ten en cuenta que solo los elementos visibles pueden capturar la entrada del ratón. Llamar a `grabMouse()` en un elemento invisible no tiene ningún efecto.

Los eventos de teclado no se ven afectados.

Véase también QGraphicsScene::mouseGrabberItem(), ungrabMouse() y grabKeyboard().

QGraphicsEffect *QGraphicsItem::graphicsEffect() const

Devuelve un puntero al efecto de este elemento, si lo tiene; en caso contrario, nullptr.

Véase también setGraphicsEffect().

QGraphicsItemGroup *QGraphicsItem::group() const

Devuelve un puntero al grupo de elementos de este elemento, o nullptr si este elemento no forma parte de ningún grupo.

Véase también setGroup(), QGraphicsItemGroup y QGraphicsScene::createItemGroup().

bool QGraphicsItem::hasCursor() const

Devuelve ` true ` si este elemento tiene un cursor establecido; en caso contrario, devuelve `false`.

Por defecto, los elementos no tienen ningún cursor establecido. cursor() devolverá un cursor de flecha de puntero estándar.

Véase también unsetCursor().

bool QGraphicsItem::hasFocus() const

Devuelve « true » si este elemento está activo y él mismo o su « focus proxy » tienen el foco de entrada del teclado; en caso contrario, devuelve « false ».

Véase también focusItem(), setFocus(), QGraphicsScene::setFocusItem() y isActive().

void QGraphicsItem::hide()

Oculta el elemento (los elementos están visibles por defecto).

Esta función de conveniencia equivale a llamar a setVisible(false).

Véase también show() y setVisible().

[virtual protected] void QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)

Este controlador de eventos, para el evento « event », se puede reimplementar para recibir eventos de entrada al pasar el cursor por encima de este elemento. La implementación predeterminada llama a « update()»; en caso contrario, no realiza ninguna acción.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` en ` event ` no tiene ningún efecto.

Véase también hoverMoveEvent(), hoverLeaveEvent(), sceneEvent() y setAcceptHoverEvents().

[virtual protected] void QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de salida al pasar el cursor por encima de este elemento. La implementación predeterminada llama a « update()»; en caso contrario, no realiza ninguna acción.

La llamada a QEvent::ignore() o a QEvent::accept() en event no tiene ningún efecto.

Véase también hoverEnterEvent(), hoverMoveEvent(), sceneEvent() y setAcceptHoverEvents().

[virtual protected] void QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de desplazamiento al pasar el cursor por este elemento. La implementación predeterminada no realiza ninguna acción.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` en ` event ` no tiene ningún efecto.

Véase también hoverEnterEvent(), hoverLeaveEvent(), sceneEvent() y setAcceptHoverEvents().

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

Este controlador de eventos, para el evento ` event`, puede reimplementarse para recibir eventos del método de entrada para este elemento. La implementación predeterminada ignora el evento.

Véase también ` inputMethodQuery()` y ` sceneEvent()`.

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Devuelve las indicaciones actuales del método de entrada de este elemento.

Las sugerencias del método de entrada solo son relevantes para los elementos de entrada. El método de entrada utiliza estas sugerencias para indicar cómo debe funcionar. Por ejemplo, si se establece el indicador Qt::ImhNumbersOnly, el método de entrada puede cambiar sus componentes visuales para reflejar que solo se pueden introducir números.

El efecto puede variar según la implementación del método de entrada.

Véase también setInputMethodHints() y inputMethodQuery().

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

Este método solo es relevante para los elementos de entrada. El método de entrada lo utiliza para consultar un conjunto de propiedades del elemento con el fin de poder admitir operaciones complejas del método de entrada, como el tratamiento del texto circundante y las reconversiones. query especifica qué propiedad se consulta.

Véase también inputMethodEvent() y QInputMethodEvent.

void QGraphicsItem::installSceneEventFilter(QGraphicsItem *filterItem)

Instala un filtro de eventos para este elemento en filterItem, lo que hace que todos los eventos de este elemento pasen primero por la función sceneEventFilter() de filterItem.

Para filtrar los eventos de otro elemento, instala este elemento como filtro de eventos para ese otro elemento. Ejemplo:

QGraphicsScene scene;
QGraphicsEllipseItem *ellipse = scene.addEllipse(QRectF(-10, -10, 20, 20));
QGraphicsLineItem *line = scene.addLine(QLineF(-10, -10, 20, 20));

line->installSceneEventFilter(ellipse);
// line's events are filtered by ellipse's sceneEventFilter() function.

ellipse->installSceneEventFilter(line);
// ellipse's events are filtered by line's sceneEventFilter() function.

Un elemento solo puede filtrar eventos de otros elementos de la misma escena. Además, un elemento no puede filtrar sus propios eventos; en su lugar, puedes reimplementar directamente sceneEvent().

Los elementos deben pertenecer a una escena para que se puedan instalar y utilizar los filtros de eventos de escena.

Véase también removeSceneEventFilter(), sceneEventFilter() y sceneEvent().

bool QGraphicsItem::isActive() const

Devuelve « true » si este elemento está activo; en caso contrario, devuelve « false ».

Un elemento solo puede estar activo si la escena está activa. Un elemento está activo si es un panel activo o si es descendiente de uno. Los elementos de los paneles no activos no están activos.

Los elementos que no forman parte de un panel siguen la activación de la escena cuando esta no tiene ningún panel activo.

Solo los elementos activos pueden recibir el foco de entrada.

Véanse también QGraphicsScene::isActive(), QGraphicsScene::activePanel(), panel() y isPanel().

bool QGraphicsItem::isAncestorOf(const QGraphicsItem *child) const

Devuelve « true » si este elemento es un antecesor de « child » (es decir, si este elemento es el padre de « child » o uno de los antecesores de los padres de « child »).

Véase también parentItem().

bool QGraphicsItem::isBlockedByModalPanel(QGraphicsItem **blockingPanel = nullptr) const

Devuelve « true » si este elemento está bloqueado por un panel modal; en caso contrario, devuelve «false». Si « blockingPanel » es distinto de cero, « blockingPanel » se establecerá en el panel modal que está bloqueando este elemento. Si este elemento no está bloqueado, esta función no establecerá « blockingPanel ».

Esta función siempre devuelve « false » para los elementos que no se encuentran en una escena.

Véase también panelModality(), setPanelModality() y PanelModality.

bool QGraphicsItem::isClipped() const

Devuelve « true » si este elemento está recortado. Un elemento está recortado si tiene activado el indicador « ItemClipsToShape » o si él mismo o cualquiera de sus antecesores tiene activado el indicador « ItemClipsChildrenToShape ».

El recorte afecta a la apariencia del elemento (es decir, a su representación gráfica), así como a la entrega de eventos de ratón y de paso del cursor.

Véase también clipPath(), shape() y setFlags().

bool QGraphicsItem::isEnabled() const

Devuelve ` true ` si el elemento está habilitado; en caso contrario, devuelve `false`.

Véase también setEnabled().

bool QGraphicsItem::isObscured(const QRectF &rect = QRectF()) const

Devuelve « true » si « rect » queda completamente oculto por la forma opaca de cualquiera de los elementos con los que colisiona situados por encima de él (es decir, con un valor Z superior al de este elemento).

Esta es una función sobrecargada.

Véase también opaqueArea().

bool QGraphicsItem::isObscured(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `isObscured(QRectF(x, y, w, h))`.

Se trata de una función sobrecargada.

[virtual] bool QGraphicsItem::isObscuredBy(const QGraphicsItem *item) const

Devuelve ` true ` si el rectángulo delimitador de este elemento queda completamente oculto por la forma opaca de ` item`.

La implementación básica mapea la función ` opaqueArea()` de ` item` al sistema de coordenadas de este elemento y, a continuación, comprueba si la función ` boundingRect()` de este elemento queda totalmente contenida dentro de la forma mapeada.

Puedes reimplementar esta función para proporcionar un algoritmo personalizado que determine si este elemento queda oculto por item.

Véanse también opaqueArea() y isObscured().

bool QGraphicsItem::isPanel() const

Devuelve « true » si el elemento es un panel; en caso contrario, devuelve « false ».

Véase también ` QGraphicsItem::panel()` y ` ItemIsPanel`.

bool QGraphicsItem::isSelected() const

Devuelve « true » si este elemento está seleccionado; en caso contrario, devuelve «false».

Los elementos que forman parte de un grupo heredan el estado de selección del grupo.

Los elementos no están seleccionados por defecto.

Véase también setSelected() y QGraphicsScene::setSelectionArea().

bool QGraphicsItem::isUnderMouse() const

Devuelve ` true ` si este elemento se encuentra actualmente bajo el cursor del ratón en alguna de las vistas; en caso contrario, se devuelve `false`.

Véase también QGraphicsScene::views() y QCursor::pos().

bool QGraphicsItem::isVisible() const

Devuelve « true » si el elemento es visible; en caso contrario, devuelve «false».

Ten en cuenta que la visibilidad general del elemento no tiene nada que ver con si realmente está siendo visualizado por un QGraphicsView.

Véase también setVisible().

bool QGraphicsItem::isVisibleTo(const QGraphicsItem *parent) const

Devuelve ` true ` si el elemento es visible para ` parent`; en caso contrario, devuelve `false`. ` parent ` puede ser ` nullptr`, en cuyo caso esta función indicará si el elemento es visible para la escena o no.

Es posible que un elemento no sea visible para sus antecesores aunque isVisible() sea verdadero. También puede ser visible para sus antecesores aunque isVisible() sea falso. Si algún antecesor está oculto, el propio elemento quedará implícitamente oculto, en cuyo caso esta función devolverá falso.

Véanse también isVisible() y setVisible().

bool QGraphicsItem::isWidget() const

Devuelve « true » si este elemento es un widget (es decir, « QGraphicsWidget »); en caso contrario, devuelve « false ».

bool QGraphicsItem::isWindow() const

Devuelve ` true ` si el elemento es una ventana ` QGraphicsWidget `; en caso contrario, devuelve `false`.

Véase también QGraphicsWidget::windowFlags().

[virtual protected] QVariant QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)

QGraphicsItem llama a esta función virtual para notificar a los elementos personalizados que se ha producido un cambio en alguna parte del estado del elemento. Al reimplementar esta función, puedes reaccionar ante un cambio y, en algunos casos (dependiendo de change), se pueden realizar ajustes.

change es el parámetro del elemento que está cambiando. value es el nuevo valor; el tipo del valor depende de change.

Ejemplo:

QVariant Component::itemChange(GraphicsItemChange change, const QVariant &value)
{
    if (change == ItemPositionChange && scene()) {
        // value is the new position.
        QPointF newPos = value.toPointF();
        QRectF rect = scene()->sceneRect();
        if (!rect.contains(newPos)) {
            // Keep the item inside the scene rect.
            newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
            newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
            return newPos;
        }
    }
    return QGraphicsItem::itemChange(change, value);
}

La implementación por defecto no realiza ninguna acción y devuelve value.

Nota: Algunas funciones de QGraphicsItem no se pueden invocar en una reimplementación de esta función; consulta la documentación de GraphicsItemChange para obtener más detalles.

Véase también GraphicsItemChange.

QTransform QGraphicsItem::itemTransform(const QGraphicsItem *other, bool *ok = nullptr) const

Devuelve una transformación de tipo ` QTransform ` que mapea las coordenadas de este elemento a ` other`. Si ` ok ` no es nulo y no existe dicha transformación, el valor booleano al que apunta ` ok ` se establecerá en `false`; en caso contrario, se establecerá en `true`.

Esta transformación ofrece una alternativa a las funciones mapToItem() o mapFromItem(), ya que devuelve la transformación adecuada para que puedas asignar formas y coordenadas por ti mismo. También te ayuda a escribir código más eficiente cuando realizas asignaciones repetidas entre los mismos dos elementos.

Nota: En contadas ocasiones, no existe ninguna transformación que establezca una correspondencia entre dos elementos.

Véase también mapToItem(), mapFromItem() y deviceTransform().

[virtual protected] void QGraphicsItem::keyPressEvent(QKeyEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de pulsación de teclas para este elemento. La implementación por defecto ignora el evento. Si reimplementas este controlador, el evento se aceptará de forma predeterminada.

Ten en cuenta que solo se reciben eventos de teclas para los elementos que tienen activada la opción « ItemIsFocusable » y que tienen el foco de entrada del teclado.

Véanse también keyReleaseEvent(), setFocus(), QGraphicsScene::setFocusItem() y sceneEvent().

[virtual protected] void QGraphicsItem::keyReleaseEvent(QKeyEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de liberación de teclas para este elemento. La implementación predeterminada ignora el evento. Si reimplementas este controlador, el evento se aceptará de forma predeterminada.

Ten en cuenta que los eventos de teclas solo se reciben para los elementos que tienen activada la bandera « ItemIsFocusable » y que tienen el foco de entrada del teclado.

Véanse también keyPressEvent(), setFocus(), QGraphicsScene::setFocusItem() y sceneEvent().

QPainterPath QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPainterPath &path) const

Asigna la ruta path —que se encuentra en el sistema de coordenadas de item — al sistema de coordenadas de este elemento, y devuelve la ruta asignada.

Si item es nullptr, esta función devuelve lo mismo que mapFromScene().

Véase también itemTransform(), mapFromParent(), mapFromScene(), mapToItem() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPointF &point) const

Asigna el punto point, que se encuentra en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

Si item es nullptr, esta función devuelve lo mismo que mapFromScene().

Véase también itemTransform(), mapFromParent(), mapFromScene(), transform(), mapToItem() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Asigna el polígono polygon, que se encuentra en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el polígono asignado.

Si item es nullptr, esta función devuelve lo mismo que mapFromScene().

Véase también itemTransform(), mapToItem(), mapFromParent(), transform() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un polígono.

Si item es nullptr, esta función devuelve lo mismo que mapFromScene()

Véase también itemTransform(), mapToItem(), mapFromParent(), transform() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapFromItem(item, QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y) const

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

Se trata de una función sobrecargada.

QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path) const

Asigna la ruta path —que se encuentra en el sistema de coordenadas del elemento padre de este— al sistema de coordenadas de este elemento, y devuelve la ruta asignada.

Véase también mapFromScene(), mapFromItem(), mapToParent() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapFromParent(const QPointF &point) const

Asigna el punto point —que se encuentra en el sistema de coordenadas del elemento padre de este elemento— al sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

Véase también mapFromItem(), mapFromScene(), transform(), mapToParent() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon) const

Realiza la conversión del polígono polygon —que se encuentra en el sistema de coordenadas del elemento padre de este— al sistema de coordenadas de este elemento, y devuelve el polígono convertido.

Véase también mapToParent(), mapToItem(), transform() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const

Asigna el rectángulo rect —que se encuentra en el sistema de coordenadas del elemento padre de este— al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un polígono.

Véase también mapToParent(), mapFromItem(), transform() y El sistema de coordenadas de la vista gráfica.

QPolygonF QGraphicsItem::mapFromParent(qreal x, qreal y, qreal w, qreal h) const

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

QPointF QGraphicsItem::mapFromParent(qreal x, qreal y) const

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

Se trata de una función sobrecargada.

QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path) const

Asigna la ruta path —que se encuentra en el sistema de coordenadas de la escena de este elemento— al sistema de coordenadas de este elemento, y devuelve la ruta asignada.

Véase también mapFromParent(), mapFromItem(), mapToScene() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapFromScene(const QPointF &point) const

Asigna el punto point —que se encuentra en el sistema de coordenadas de la escena de este elemento— al sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

Véase también mapFromItem(), mapFromParent(), transform(), mapToScene() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon) const

Asigna el polígono polygon, que se encuentra en el sistema de coordenadas de la escena de este elemento, al sistema de coordenadas de este elemento, y devuelve el polígono asignado.

Véase también mapToScene(), mapFromParent(), transform() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const

Asigna el rectángulo rect —que se encuentra en el sistema de coordenadas de la escena de este elemento— al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un polígono.

Véase también mapToScene(), mapFromItem(), transform() y El sistema de coordenadas de la vista gráfica.

QPolygonF QGraphicsItem::mapFromScene(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapFromScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapFromScene(qreal x, qreal y) const

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

Se trata de una función sobrecargada.

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Si item es nullptr, esta función devuelve lo mismo que mapRectFromScene().

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectFromItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const

Asigna el rectángulo rect —que se encuentra en el sistema de coordenadas del elemento padre de este elemento— al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectFromParent(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectFromParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect) const

Asigna el rectángulo rect —que está en coordenadas de escena— al sistema de coordenadas de este elemento, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectFromScene(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectFromScene(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Si item es nullptr, esta función devuelve lo mismo que mapRectToScene().

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectToItem(item, QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToParent(const QRectF &rect) const

Asigna el rectángulo rect —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de su elemento padre, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectToParent(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectToParent(QRectF(x, y, w, h))`.

QRectF QGraphicsItem::mapRectToScene(const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el rectángulo asignado como un nuevo rectángulo (es decir, el rectángulo delimitador del polígono resultante).

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QRectF QGraphicsItem::mapRectToScene(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapRectToScene(QRectF(x, y, w, h))`.

QPainterPath QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPainterPath &path) const

Asigna la ruta path —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de item, y devuelve la ruta asignada.

Si item es nullptr, esta función devuelve lo mismo que mapToScene().

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPointF &point) const

Asigna el punto point —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de item, y devuelve la coordenada asignada.

Si item es nullptr, esta función devuelve lo mismo que mapToScene().

Véase también itemTransform(), mapToParent(), mapToScene(), transform(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPolygonF &polygon) const

Asigna el polígono polygon, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el polígono asignado.

Si item es nullptr, esta función devuelve lo mismo que mapToScene().

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el rectángulo asignado como un polígono.

Si item es nullptr, esta función devuelve lo mismo que mapToScene().

Véase también itemTransform(), mapToParent(), mapToScene(), mapFromItem() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapToItem(item, QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y) const

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

Se trata de una función sobrecargada.

QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path) const

Asigna la ruta path —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de su elemento padre, y devuelve la ruta asignada. Si el elemento no tiene elemento padre, path se asignará al sistema de coordenadas de la escena.

Véase también mapToScene(), mapToItem(), mapFromParent() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapToParent(const QPointF &point) const

Asigna el punto point —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de su elemento padre, y devuelve la coordenada asignada. Si el elemento no tiene elemento padre, point se asignará al sistema de coordenadas de la escena.

Véase también mapToItem(), mapToScene(), transform(), mapFromParent() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon) const

Asigna el polígono polygon —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de su elemento padre, y devuelve el polígono asignado. Si el elemento no tiene elemento padre, polygon se asignará al sistema de coordenadas de la escena.

Véase también mapToScene(), mapToItem(), mapFromParent() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToParent(const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de su elemento padre, y devuelve el rectángulo asignado como un polígono. Si el elemento no tiene elemento padre, rect se asignará al sistema de coordenadas de la escena.

Véase también mapToScene(), mapToItem(), mapFromParent() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToParent(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapToParent(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToParent(qreal x, qreal y) const

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

Se trata de una función sobrecargada.

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

Asigna la ruta path —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de la escena, y devuelve la ruta asignada.

Véase también mapToParent(), mapToItem(), mapFromScene() y «El sistema de coordenadas de la vista gráfica».

QPointF QGraphicsItem::mapToScene(const QPointF &point) const

Asigna el punto point —que se encuentra en el sistema de coordenadas de este elemento— al sistema de coordenadas de la escena, y devuelve la coordenada asignada.

Véase también mapToItem(), mapToParent(), transform(), mapFromScene() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon) const

Asigna el polígono polygon, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el polígono asignado.

Véase también mapToParent(), mapToItem(), mapFromScene() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToScene(const QRectF &rect) const

Asigna el rectángulo rect, que se encuentra en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el rectángulo asignado como un polígono.

Véase también mapToParent(), mapToItem(), mapFromScene() y «El sistema de coordenadas de la vista gráfica».

QPolygonF QGraphicsItem::mapToScene(qreal x, qreal y, qreal w, qreal h) const

Esta función de conveniencia equivale a llamar a `mapToScene(QRectF(x, y, w, h))`.

QPointF QGraphicsItem::mapToScene(qreal x, qreal y) const

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

Se trata de una función sobrecargada.

[virtual protected] void QGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de doble clic del ratón para este elemento.

Al hacer doble clic en un elemento, este recibirá primero un evento de pulsación del ratón, seguido de un evento de liberación (es decir, un clic), luego un evento de doble clic y, por último, un evento de liberación.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` en ` event ` no tiene ningún efecto.

La implementación predeterminada llama a mousePressEvent(). Si desea conservar la implementación base al reimplementar esta función, llame a QGraphicsItem::mouseDoubleClickEvent() en su reimplementación.

Ten en cuenta que un elemento no recibirá eventos de doble clic si no es ni « selectable » ni « movable » (en este caso se ignoran los clics simples del ratón, lo que impide que se generen los dobles clics).

Véase también mousePressEvent(), mouseMoveEvent(), mouseReleaseEvent() y sceneEvent().

[virtual protected] void QGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de movimiento del ratón para este elemento. Si recibes este evento, puedes estar seguro de que este elemento también ha recibido un evento de pulsación del ratón y de que este elemento es el que tiene actualmente el control del ratón.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` sobre ` event ` no tiene ningún efecto.

La implementación por defecto gestiona la interacción básica con los elementos, como la selección y el desplazamiento. Si desea conservar la implementación base al reimplementar esta función, llame a `QGraphicsItem::mouseMoveEvent()` en su reimplementación.

Ten en cuenta que mousePressEvent() determina qué elemento gráfico recibe los eventos del ratón. Consulta la descripción de mousePressEvent() para obtener más detalles.

Véanse también mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() y sceneEvent().

[virtual protected] void QGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de pulsación del ratón para este elemento. Los eventos de pulsación del ratón solo se envían a los elementos que aceptan el botón del ratón que se ha pulsado. Por defecto, un elemento acepta todos los botones del ratón, pero puedes cambiar esto llamando a « setAcceptedMouseButtons()».

El evento de pulsación del ratón determina qué elemento debe convertirse en el «captador del ratón» (véase QGraphicsScene::mouseGrabberItem()). Si no se reimplementa esta función, el evento de pulsación se propagará a cualquier elemento situado en primer plano por debajo de este elemento, y no se enviarán otros eventos del ratón a este elemento.

Si reimplementas esta función, se aceptará por defecto « event » (véase QEvent::accept()), y este elemento se convertirá entonces en el «mouse grabber». Esto permite que el elemento reciba futuros eventos de desplazamiento, liberación y doble clic. Si llamas a QEvent::ignore() en event, este elemento perderá el control del ratón, y event se propagará a cualquier elemento situado más arriba que se encuentre debajo. No se enviarán más eventos de ratón a este elemento a menos que se reciba un nuevo evento de pulsación del ratón.

La implementación por defecto gestiona la interacción básica con los elementos, como la selección y el desplazamiento. Si desea conservar la implementación base al reimplementar esta función, llame a `QGraphicsItem::mousePressEvent()` en su reimplementación.

El evento se QEvent::ignore()d para los elementos que no son ni movable ni selectable.

Véase también mouseMoveEvent(), mouseReleaseEvent(), mouseDoubleClickEvent() y sceneEvent().

[virtual protected] void QGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

Este controlador de eventos, para el evento « event », se puede reimplementar para recibir eventos de liberación del ratón para este elemento.

Llamar a ` QEvent::ignore()` o a ` QEvent::accept()` en ` event ` no tiene ningún efecto.

La implementación predeterminada gestiona la interacción básica con los elementos, como la selección y el desplazamiento. Si deseas conservar la implementación base al reimplementar esta función, llama a `QGraphicsItem::mouseReleaseEvent()` en tu reimplementación.

Ten en cuenta que mousePressEvent() determina qué elemento gráfico recibe los eventos del ratón. Consulta la descripción de mousePressEvent() para obtener más detalles.

Véanse también mousePressEvent(), mouseMoveEvent(), mouseDoubleClickEvent() y sceneEvent().

void QGraphicsItem::moveBy(qreal dx, qreal dy)

Desplaza el elemento un dx puntos en horizontal y un dy punto en vertical. Esta función equivale a llamar a setPos(pos() + QPointF(dx, dy)).

qreal QGraphicsItem::opacity() const

Devuelve la opacidad local de este elemento, que oscila entre 0,0 (transparente) y 1,0 (opaco). Este valor se combina con los valores del elemento padre y de los antepasados en la función ` effectiveOpacity()`. La opacidad efectiva determina cómo se representa el elemento y también afecta a su visibilidad cuando se consulta mediante funciones como ` QGraphicsView::items()`.

La propiedad «opacity» determina el estado del «painter» que se pasa a la función « paint()». Si el elemento está almacenado en caché, es decir, « ItemCoordinateCache » o « DeviceCoordinateCache », la propiedad efectiva se aplicará a la caché del elemento a medida que se represente.

La opacidad predeterminada es 1,0; totalmente opaco.

Véase también setOpacity(), paint(), ItemIgnoresParentOpacity y ItemDoesntPropagateOpacityToChildren.

[virtual] QPainterPath QGraphicsItem::opaqueArea() const

Esta función virtual devuelve una forma que representa el área en la que este elemento es opaco. Un área es opaca si se rellena con un pincel o un color opaco (es decir, que no sea transparente).

Esta función es utilizada por ` isObscuredBy()`, que es invocada por los elementos subyacentes para determinar si quedan ocultos por este elemento.

La implementación por defecto devuelve un ` QPainterPath` vacío, lo que indica que este elemento es completamente transparente y no oculta ningún otro elemento.

Véase también isObscuredBy(), isObscured() y shape().

[pure virtual] void QGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr)

Esta función, que suele ser llamada por ` QGraphicsView`, dibuja el contenido de un elemento en coordenadas locales.

Reimplementa esta función en una subclase de ` QGraphicsItem ` para proporcionar la implementación de dibujo del elemento, utilizando ` painter`. El parámetro ` option ` proporciona opciones de estilo para el elemento, como su estado, el área expuesta y las indicaciones sobre el nivel de detalle. El argumento ` widget ` es opcional. Si se proporciona, apunta al widget sobre el que se está dibujando; de lo contrario, es 0. Para el dibujo en caché, ` widget ` es siempre 0.

void RoundRectItem::paint(QPainter *painter,
                          const QStyleOptionGraphicsItem *option,
                          QWidget *widget)
{
    painter->drawRoundedRect(-10, -10, 20, 20, 5, 5);
}

El lápiz del pintor tiene un ancho de 0 por defecto, y se inicializa con el pincel QPalette::Text de la paleta del dispositivo de pintura. El pincel se inicializa con QPalette::Window.

Asegúrate de limitar todo el dibujo dentro de los límites de boundingRect() para evitar artefactos de renderizado (ya que QGraphicsView no recorta el pintor por ti). En concreto, cuando QPainter dibuja el contorno de una forma utilizando un QPen asignado, la mitad del contorno se dibujará fuera y la otra mitad dentro de la forma que se está representando (por ejemplo, con un ancho de trazo de 2 unidades, debes dibujar los contornos 1 unidad dentro de boundingRect()). QGraphicsItem no admite el uso de trazos decorativos con un ancho distinto de cero.

Todo el dibujo se realiza en coordenadas locales.

Nota: Es obligatorio que un elemento se redibuje siempre exactamente de la misma manera, a menos que se haya llamado a update(); de lo contrario, pueden producirse artefactos visuales. En otras palabras, dos llamadas consecutivas a paint() deben producir siempre el mismo resultado, a menos que se haya llamado a update() entre ellas.

Nota: Habilitar el almacenamiento en caché para un elemento no garantiza que el marco Graphics View invoque a paint() solo una vez, incluso sin ninguna llamada explícita a update(). Consulta la documentación de setCacheMode() para obtener más detalles.

Véase también setCacheMode(), QPen::width(), «Coordenadas de elementos» y ItemUsesExtendedStyleOption.

QGraphicsItem *QGraphicsItem::panel() const

Devuelve el panel del elemento o nullptr si dicho elemento no tiene ningún panel. Si el elemento es un panel, devolverá el propio elemento. En caso contrario, devolverá el antepasado más cercano que sea un panel.

Véase también isPanel() y ItemIsPanel.

QGraphicsItem::PanelModality QGraphicsItem::panelModality() const

Devuelve la modalidad de este elemento.

Véase también setPanelModality().

QGraphicsItem *QGraphicsItem::parentItem() const

Devuelve un puntero al elemento padre de este elemento. Si este elemento no tiene un elemento padre, se devuelve « nullptr ».

Véase también setParentItem() y childItems().

QGraphicsObject *QGraphicsItem::parentObject() const

Devuelve un puntero al elemento padre del elemento, convertido a un ` QGraphicsObject`. Devuelve ` nullptr ` si el elemento padre no es un ` QGraphicsObject`.

Véase también parentItem() y childItems().

QGraphicsWidget *QGraphicsItem::parentWidget() const

Devuelve un puntero al widget padre del elemento. El widget padre del elemento es el elemento padre más cercano que sea un widget.

Véase también parentItem() y childItems().

QPointF QGraphicsItem::pos() const

Devuelve la posición del elemento en coordenadas del elemento padre. Si el elemento no tiene ningún elemento padre, su posición se indica en coordenadas de la escena.

La posición del elemento describe su origen (coordenada local (0, 0)) en coordenadas del elemento padre; esta función devuelve el mismo resultado que mapToParent(0, 0).

Para mayor comodidad, también puedes llamar a scenePos() para determinar la posición del elemento en coordenadas de escena, independientemente de su elemento padre.

Véase también x(), y(), setPos(), transform() y El sistema de coordenadas de la vista gráfica.

[protected] void QGraphicsItem::prepareGeometryChange()

Prepara el elemento para un cambio de geometría. Llama a esta función antes de modificar el rectángulo delimitador de un elemento para mantener actualizado el índice de ` QGraphicsScene`.

prepareGeometryChange() llamará a update() si es necesario.

Ejemplo:

void CircleItem::setRadius(qreal newRadius)
{
    if (radius != newRadius) {
        prepareGeometryChange();
        radius = newRadius;
    }
}

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

void QGraphicsItem::removeSceneEventFilter(QGraphicsItem *filterItem)

Elimina un filtro de eventos de este elemento de filterItem.

Véase también installSceneEventFilter().

void QGraphicsItem::resetTransform()

Restablece la matriz de transformación de este elemento a la matriz identidad o todas las propiedades de transformación a sus valores predeterminados. Esto equivale a llamar a setTransform(QTransform()).

Véase también setTransform() y transform().

qreal QGraphicsItem::rotation() const

Devuelve la rotación en sentido horario, en grados, alrededor del eje Z. El valor por defecto es 0 (es decir, el elemento no está girado).

La rotación se combina con las funciones scale(), transform() y transformations() del elemento para mapear el sistema de coordenadas del elemento al del elemento padre.

Véanse también setRotation(), transformOriginPoint() y Transformations.

qreal QGraphicsItem::scale() const

Devuelve el factor de escala del elemento. El factor de escala predeterminado es 1,0 (es decir, el elemento no se escala).

La escala se combina con las funciones ` rotation` (), ` transform` () y ` transformations` () del elemento para mapear el sistema de coordenadas del elemento al del elemento padre.

Véanse también setScale(), rotation() y Transformations.

QGraphicsScene *QGraphicsItem::scene() const

Devuelve la escena actual del elemento, o ` nullptr ` si el elemento no está almacenado en ninguna escena.

Para añadir o mover un elemento a una escena, llama a QGraphicsScene::addItem().

QRectF QGraphicsItem::sceneBoundingRect() const

Devuelve el rectángulo delimitador de este elemento en coordenadas de escena, combinando sceneTransform() con boundingRect().

Véase también boundingRect() y El sistema de coordenadas de la vista gráfica.

[virtual protected] bool QGraphicsItem::sceneEvent(QEvent *event)

Esta función virtual recibe los eventos de este elemento. Reimplementa esta función para interceptar los eventos antes de que se envíen a los controladores de eventos especializados: contextMenuEvent(), focusInEvent(), focusOutEvent(), hoverEnterEvent(), hoverMoveEvent(), hoverLeaveEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent() y mouseDoubleClickEvent().

Devuelve « true » si el evento se ha reconocido y gestionado; en caso contrario (por ejemplo, si no se ha reconocido el tipo de evento), se devuelve «false».

event es el evento interceptado.

[virtual protected] bool QGraphicsItem::sceneEventFilter(QGraphicsItem *watched, QEvent *event)

Filtra los eventos del elemento watched. event es el evento filtrado.

La reimplementación de esta función en una subclase permite que el elemento se utilice como filtro de eventos para otros elementos, interceptando todos los eventos enviados a dichos elementos antes de que estos puedan responder.

Las reimplementaciones deben devolver «true» para impedir que se siga procesando un evento determinado, asegurando así que no se envíe al elemento vigilado, o devolver «false» para indicar que el sistema de eventos debe seguir propagando el evento.

Véase también installSceneEventFilter().

QPointF QGraphicsItem::scenePos() const

Devuelve la posición del elemento en coordenadas de escena. Esto equivale a llamar a ` mapToScene(0, 0)`.

Véase también pos(), sceneTransform() y «El sistema de coordenadas de la vista gráfica».

QTransform QGraphicsItem::sceneTransform() const

Devuelve la matriz de transformación de escena de este elemento. Esta matriz se puede utilizar para mapear coordenadas y formas geométricas desde el sistema de coordenadas local de este elemento al sistema de coordenadas de la escena. Para mapear coordenadas desde la escena, primero debes invertir la matriz devuelta.

Ejemplo:

QGraphicsRectItem rect;
rect.setPos(100, 100);

rect.sceneTransform().map(QPointF(0, 0));
// returns QPointF(100, 100);

rect.sceneTransform().inverted().map(QPointF(100, 100));
// returns QPointF(0, 0);

A diferencia de transform(), que solo devuelve la transformación local de un elemento, esta función incluye la posición del elemento (y de cualquier elemento padre), así como todas las propiedades de transformación.

Véase también transform(), setTransform(), scenePos(), El sistema de coordenadas de la vista gráfica y Transformations.

void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF &rect = QRectF())

Desplaza el contenido de rect de dx, dy. Si rect es un rectángulo nulo (por defecto), se desplaza el rectángulo delimitador del elemento.

El desplazamiento ofrece una alternativa rápida al simple redibujado cuando el contenido del elemento (o partes del mismo) se desplaza vertical u horizontalmente. Dependiendo de la transformación actual y de las capacidades del dispositivo de dibujo (es decir, la ventana gráfica), esta operación puede consistir simplemente en mover píxeles de una ubicación a otra utilizando memmove(). En la mayoría de los casos, esto es más rápido que volver a renderizar toda el área.

Tras el desplazamiento, el elemento emitirá una actualización para las áreas recién expuestas. Si el desplazamiento no está admitido (por ejemplo, si se está renderizando en una ventana gráfica de OpenGL, que no se beneficia de las optimizaciones de desplazamiento), esta función equivale a llamar a update(rect).

Nota: El desplazamiento solo está disponible cuando QGraphicsItem::ItemCoordinateCache está habilitado; en todos los demás casos, llamar a esta función equivale a llamar a update(rect). Si sabes con certeza que el elemento es opaco y no se superpone con otros elementos, puedes mapear el rect a las coordenadas de la ventana gráfica y desplazar la ventana gráfica.

QTransform xform = item->deviceTransform(view->viewportTransform());
QRect deviceRect = xform.mapRect(rect).toAlignedRect();
view->viewport()->scroll(dx, dy, deviceRect);

Véase también boundingRect().

void QGraphicsItem::setAcceptDrops(bool on)

Si on es verdadero, este elemento aceptará eventos de arrastrar y soltar; en caso contrario, será transparente a dichos eventos. Por defecto, los elementos no aceptan eventos de arrastrar y soltar.

Véase también acceptDrops().

void QGraphicsItem::setAcceptHoverEvents(bool enabled)

Si enabled es verdadero, este elemento aceptará eventos de desplazamiento del cursor; de lo contrario, los ignorará. Por defecto, los elementos no aceptan eventos de desplazamiento del cursor.

Los eventos de desplazamiento se producen cuando no hay ningún elemento que haya capturado el ratón. Se envían cuando el cursor del ratón entra en un elemento, cuando se desplaza por su interior y cuando sale de él. Los eventos de desplazamiento se utilizan habitualmente para resaltar un elemento al entrar en él y para seguir el cursor del ratón mientras se desplaza sobre el elemento (equivalente a QWidget::mouseTracking).

Los elementos padres reciben los eventos de entrada de desplazamiento antes que sus elementos hijos, y los de salida después que estos. Sin embargo, el elemento padre no recibe un evento de salida de desplazamiento si el cursor entra en un elemento hijo; el elemento padre permanece en estado de «desplazamiento» hasta que el cursor abandona su área, incluidas las áreas de sus elementos hijos.

Si un elemento padre gestiona los eventos de sus elementos hijos, recibirá eventos de desplazamiento al pasar el cursor por encima de ellos y de desplazamiento al arrastrar y soltar a medida que el cursor atraviesa sus elementos hijos, pero no recibirá eventos de entrada y salida al pasar el cursor, ni de entrada y salida al arrastrar en nombre de sus elementos hijos.

Un « QGraphicsWidget » con decoraciones de ventana aceptará eventos «hover» independientemente del valor de « acceptHoverEvents()».

Véase también « acceptHoverEvents()», « hoverEnterEvent()», « hoverMoveEvent()» y « hoverLeaveEvent()».

void QGraphicsItem::setAcceptTouchEvents(bool enabled)

Si enabled es verdadero, este elemento aceptará touch events; de lo contrario, los ignorará. Por defecto, los elementos no aceptan eventos táctiles.

Véase también acceptTouchEvents().

void QGraphicsItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)

Establece el « buttons » del ratón para el que este elemento acepta eventos del ratón.

Por defecto, se aceptan todos los botones del ratón. Si un elemento acepta un botón del ratón, se convertirá en el elemento «grabber» cuando se produzca un evento de pulsación de ratón para ese botón. Sin embargo, si el elemento no acepta el botón del ratón, QGraphicsScene reenviará los eventos del ratón al primer elemento situado debajo de él que sí lo acepte.

Para desactivar los eventos del ratón para un elemento (es decir, hacer que sea transparente a los eventos del ratón), llama a setAcceptedMouseButtons(Qt::NoButton).

Véanse también acceptedMouseButtons() y mousePressEvent().

void QGraphicsItem::setActive(bool active)

Si « active » es «true» y la escena está activa, se activará el panel de este elemento. En caso contrario, el panel permanecerá desactivado.

Si el elemento no forma parte de una escena activa, la propiedad « active » determinará qué ocurre con el panel cuando la escena se active o cuando el elemento se añada a la escena. Si el valor es «true», el panel del elemento se activará cuando el elemento se añada a la escena o cuando la escena se active. En caso contrario, el elemento permanecerá inactivo independientemente del estado de activación de la escena.

Véase también isPanel(), QGraphicsScene::setActivePanel() y QGraphicsScene::isActive().

void QGraphicsItem::setBoundingRegionGranularity(qreal granularity)

Establece la granularidad de la región delimitadora en granularity; un valor comprendido entre 0 y 1, ambos incluidos. El valor por defecto es 0 (es decir, la granularidad más baja, en la que la región delimitadora se corresponde con el rectángulo delimitador del elemento).

boundingRegion() utiliza la granularidad para calcular el nivel de detalle que debe tener la región delimitadora del elemento. La granularidad máxima alcanzable es 1, en cuyo caso boundingRegion() devolverá el contorno más detallado posible para el dispositivo en cuestión (por ejemplo, para una ventana de visualización de QGraphicsView, esto proporciona una región delimitadora con precisión al píxel). La granularidad más baja posible es 0. El valor de granularity describe la relación entre la resolución del dispositivo y la resolución de la región delimitadora (por ejemplo, un valor de 0,25 proporcionará una región en la que cada fragmento se corresponda con 4x4 unidades del dispositivo / píxeles).

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

void QGraphicsItem::setCacheMode(QGraphicsItem::CacheMode mode, const QSize &logicalCacheSize = QSize())

Establece el modo de caché del elemento en « mode ».

El argumento opcional « logicalCacheSize » solo se utiliza en el modo « ItemCoordinateCache » y describe la resolución del búfer de caché; si « logicalCacheSize » es (100, 100), « QGraphicsItem » ajustará el elemento a 100x100 píxeles en la memoria gráfica, independientemente del tamaño lógico del propio elemento. Por defecto, « QGraphicsItem » utiliza el tamaño de « boundingRect()». Para todos los modos de caché distintos de « ItemCoordinateCache », se ignora « logicalCacheSize ».

El almacenamiento en caché puede acelerar el renderizado si el elemento dedica un tiempo considerable a redibujarse. En algunos casos, la caché también puede ralentizar el renderizado, sobre todo cuando el elemento dedica menos tiempo a redibujarse que el que tarda QGraphicsItem en redibujarlo desde la caché.

Cuando el almacenamiento en caché está habilitado, la función paint() de un elemento suele dibujar en una caché de mapa de píxeles fuera de pantalla; para cualquier solicitud de redibujado posterior, el marco de trabajo de Graphics View volverá a dibujar desde la caché. Este enfoque funciona especialmente bien con QGLWidget, que almacena toda la caché como texturas OpenGL.

Ten en cuenta que puede ser necesario modificar el límite de caché de QPixmapCache para obtener un rendimiento óptimo.

Puedes obtener más información sobre los diferentes modos de caché en la documentación de CacheMode.

Nota: Habilitar el almacenamiento en caché no implica que la función paint() del elemento se llame únicamente en respuesta a una llamada explícita a update(). Por ejemplo, en caso de presión de memoria, Qt puede decidir descartar parte de la información de la caché; en tales casos, se llamará a la función paint() del elemento incluso si no se ha producido ninguna llamada a update() (es decir, exactamente como si no se hubiera habilitado el almacenamiento en caché).

Véase también cacheMode(), CacheMode y QPixmapCache::setCacheLimit().

void QGraphicsItem::setCursor(const QCursor &cursor)

Establece la forma actual del cursor para el elemento en cursor. El cursor del ratón adoptará esta forma cuando se sitúe sobre dicho elemento. Consulta list of predefined cursor objects para ver una selección de formas útiles.

Es posible que un elemento del editor quiera utilizar un cursor en forma de viga en I:

item->setCursor(Qt::IBeamCursor);

Si no se ha establecido ningún cursor, se utiliza el cursor del elemento subyacente.

Véanse también cursor(), hasCursor(), unsetCursor(), QWidget::cursor y QGuiApplication::overrideCursor().

void QGraphicsItem::setData(int key, const QVariant &value)

Establece los datos personalizados de este elemento para la clave « key » en « value ».

Los datos personalizados de los elementos son útiles para almacenar propiedades arbitrarias de cualquier elemento. Qt no utiliza esta función para almacenar datos; se proporciona únicamente para comodidad del usuario.

Véase también data().

void QGraphicsItem::setEnabled(bool enabled)

Si enabled es «true», el elemento está habilitado; en caso contrario, está deshabilitado.

Los elementos desactivados son visibles, pero no reciben ningún evento y no pueden recibir el foco ni ser seleccionados. Los eventos del ratón se descartan; no se propagan a menos que el elemento también sea invisible o que no acepte eventos del ratón (véase acceptedMouseButtons()). Un elemento desactivado no puede convertirse en el captador del ratón y, como consecuencia, un elemento pierde el control del ratón si se desactiva mientras lo tiene capturado, del mismo modo que pierde el foco si lo tenía cuando se desactivó.

Los elementos desactivados se suelen representar con colores atenuados (véase QPalette::Disabled).

Si desactivas un elemento padre, todos sus elementos hijos también quedarán desactivados. Si activas un elemento padre, todos los elementos hijos quedarán activados, a menos que se hayan desactivado explícitamente (es decir, si llamas a setEnabled(false) en un elemento hijo, este no se volverá a activar si su elemento padre se desactiva y luego se vuelve a activar).

Los elementos están habilitados de forma predeterminada.

Nota: Si instalas un filtro de eventos, podrás seguir interceptando eventos antes de que se envíen a los elementos; este mecanismo no tiene en cuenta el estado de activación del elemento.

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

void QGraphicsItem::setFiltersChildEvents(bool enabled)

Si enabled es verdadero, este elemento se configura para filtrar todos los eventos de todos sus hijos (es decir, todos los eventos destinados a cualquiera de sus hijos se envían en su lugar a este elemento); por el contrario, si enabled es falso, este elemento solo gestionará sus propios eventos. El valor por defecto es falso.

Véase también filtersChildEvents().

void QGraphicsItem::setFlag(QGraphicsItem::GraphicsItemFlag flag, bool enabled = true)

Si enabled es verdadero, se activa el indicador del elemento flag; en caso contrario, se desactiva.

Véanse también flags() y setFlags().

void QGraphicsItem::setFlags(QGraphicsItem::GraphicsItemFlags flags)

Establece los indicadores del elemento en flags. Se activan todos los indicadores que aparecen en flags; se desactivan todos los que no aparecen en flags.

Si el elemento tenía el foco y flags no habilita ItemIsFocusable, el elemento pierde el foco como resultado de la llamada a esta función. Del mismo modo, si el elemento estaba seleccionado y flags no habilita ItemIsSelectable, el elemento se deselecciona automáticamente.

Por defecto, no hay ninguna bandera activada. (QGraphicsWidget activa la bandera ItemSendsGeometryChanges por defecto para realizar un seguimiento de los cambios de posición.)

Véase también flags() y setFlag().

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

Asigna el foco de entrada del teclado a este elemento. El argumento « focusReason » se pasará a cualquier objeto « focus event » generado por esta función; se utiliza para explicar qué ha provocado que el elemento reciba el foco.

Solo los elementos habilitados que tengan activado el indicador « ItemIsFocusable » pueden recibir el foco del teclado.

Si este elemento no está visible, no está activo o no está asociado a una escena, no obtendrá el foco de entrada de forma inmediata. Sin embargo, se registrará como el elemento de foco preferido para su subárbol de elementos, en caso de que más adelante se vuelva visible.

Como resultado de llamar a esta función, este elemento recibirá un ` focus in event ` con ` focusReason`. Si otro elemento ya tiene el foco, dicho elemento recibirá primero un ` focus out event ` indicando que ha perdido el foco de entrada.

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

void QGraphicsItem::setFocusProxy(QGraphicsItem *item)

Establece el proxy de foco del elemento en item.

Si un elemento tiene un proxy de foco, este recibirá el foco de entrada cuando el elemento obtenga dicho foco. El elemento en sí seguirá teniendo el foco (es decir, hasFocus() devolverá «true»), pero solo el proxy de foco recibirá la entrada del teclado.

Un proxy de foco puede tener a su vez un proxy de foco, y así sucesivamente. En tal caso, la entrada del teclado será gestionada por el proxy de foco más externo.

El proxy de foco item debe pertenecer a la misma escena que este elemento.

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

void QGraphicsItem::setGraphicsEffect(QGraphicsEffect *effect)

Establece « effect » como efecto del elemento. Si ya hay un efecto instalado en este elemento, « QGraphicsItem » eliminará el efecto existente antes de instalar el nuevo « effect ». Puedes eliminar un efecto existente llamando a «setGraphicsEffect(nullptr)».

Si effect es el efecto instalado en otro elemento, setGraphicsEffect() eliminará el efecto de ese elemento y lo instalará en este elemento.

QGraphicsItem Asume la propiedad de effect.

Nota: Esta función aplicará el efecto sobre sí mismo y sobre todos sus elementos secundarios.

Véase también graphicsEffect().

void QGraphicsItem::setGroup(QGraphicsItemGroup *group)

Añade este elemento al grupo de elementos group. Si group es nullptr, este elemento se elimina de cualquier grupo actual y se añade como elemento secundario del elemento principal del grupo anterior.

Véase también group() y QGraphicsScene::createItemGroup().

void QGraphicsItem::setInputMethodHints(Qt::InputMethodHints hints)

Establece las sugerencias del método de entrada actual de este elemento en « hints ».

Véase también inputMethodHints() y inputMethodQuery().

void QGraphicsItem::setOpacity(qreal opacity)

Establece la opacidad local de este elemento ( opacity), entre 0,0 (transparente) y 1,0 (opaco). La opacidad local del elemento se combina con las opacidades del elemento padre y de los elementos antecesores para obtener la opacidad efectiva ( effectiveOpacity()).

Por defecto, la opacidad se propaga de los elementos padres a los hijos, por lo que si la opacidad de un elemento padre es 0,5 y la del hijo también es 0,5, la opacidad efectiva del hijo será 0,25.

La propiedad de opacidad determina el estado del «pintor» que se pasa a la función paint(). Si el elemento está almacenado en caché, es decir, ItemCoordinateCache o DeviceCoordinateCache, la propiedad efectiva se aplicará a la caché del elemento a medida que se renderiza.

Hay dos indicadores de elemento que afectan a cómo se combina la opacidad del elemento con la del padre: ItemIgnoresParentOpacity y ItemDoesntPropagateOpacityToChildren.

Nota: Establecer la opacidad de un elemento en 0 no hará que el elemento sea invisible (según isVisible()), pero el elemento se tratará como si lo fuera. Consulte la documentación de setVisible() para obtener más información.

Véanse también opacity(), effectiveOpacity() y setVisible().

void QGraphicsItem::setPanelModality(QGraphicsItem::PanelModality panelModality)

Establece la modalidad de este elemento en « panelModality ».

El cambio de la modalidad de un elemento visible surte efecto de forma inmediata.

Véase también panelModality().

void QGraphicsItem::setParentItem(QGraphicsItem *newParent)

Establece el elemento padre de este elemento en newParent. Si este elemento ya tiene un padre, primero se elimina del padre anterior. Si newParent es 0, este elemento pasará a ser un elemento de nivel superior.

Ten en cuenta que esto añade implícitamente este elemento gráfico a la escena del padre. No debes añadir tú mismo el elemento a la escena mediante ` add `.

El comportamiento al llamar a esta función sobre un elemento que sea un antepasado de newParent es indefinido.

Véanse también « parentItem()» y « childItems()».

void QGraphicsItem::setPos(const QPointF &pos)

Establece la posición del elemento en ` pos`, que se expresa en coordenadas del elemento padre. En el caso de los elementos que no tienen elemento padre, ` pos ` se expresa en coordenadas de la escena.

La posición del elemento describe su origen (coordenada local (0, 0)) en coordenadas del elemento padre.

Véase también pos(), scenePos() y «El sistema de coordenadas de la vista gráfica».

void QGraphicsItem::setPos(qreal x, qreal y)

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

Se trata de una función sobrecargada.

void QGraphicsItem::setRotation(qreal angle)

Establece la rotación en sentido horario angle, en grados, alrededor del eje Z. El valor por defecto es 0 (es decir, el elemento no gira). Si se asigna un valor negativo, el elemento girará en sentido antihorario. Normalmente, el ángulo de rotación está comprendido entre -360 y 360, pero también es posible asignar valores fuera de este rango (por ejemplo, una rotación de 370 grados equivale a una rotación de 10 grados).

El elemento gira en torno a su punto de origen de transformación, que por defecto es (0, 0). Puedes seleccionar un origen de transformación diferente llamando a setTransformOriginPoint().

La rotación se combina con las funciones ` scale()`, ` transform()` y ` transformations()` del elemento para mapear el sistema de coordenadas del elemento al del elemento padre.

Véase también rotation(), setTransformOriginPoint() y Transformations.

void QGraphicsItem::setScale(qreal factor)

Establece el factor de escala factor del elemento. El factor de escala predeterminado es 1,0 (es decir, el elemento no se escala). Un factor de escala de 0,0 reducirá el elemento a un único punto. Si se especifica un factor de escala negativo, el elemento se invertirá y se reflejará (es decir, se girará 180 grados).

El elemento se escala en torno a su punto de origen de transformación, que por defecto es (0, 0). Puedes seleccionar un origen de transformación diferente llamando a setTransformOriginPoint().

La escala se combina con las funciones rotation(), transform() y transformations() del elemento para asignar el sistema de coordenadas del elemento al elemento padre.

Véase también ` scale()`, ` setTransformOriginPoint()` y el ejemplo de transformaciones.

void QGraphicsItem::setSelected(bool selected)

Si selected es verdadero y este elemento se puede seleccionar, dicho elemento queda seleccionado; en caso contrario, queda deseleccionado.

Si el elemento forma parte de un grupo, esta función alterna el estado de selección de todo el grupo. Si el grupo está seleccionado, todos los elementos del grupo también lo están; si el grupo no está seleccionado, ningún elemento del grupo lo está.

Solo se pueden seleccionar los elementos visibles, habilitados y seleccionables. Si selected es verdadero y este elemento es invisible, está deshabilitado o no es seleccionable, esta función no realiza ninguna acción.

Por defecto, los elementos no se pueden seleccionar. Para habilitar la selección, active el indicador ` ItemIsSelectable `.

Esta función se proporciona por comodidad, ya que permite cambiar individualmente el estado de selección de un elemento. Sin embargo, una forma más habitual de seleccionar elementos es llamar a QGraphicsScene::setSelectionArea(), lo que llamará a esta función para todos los elementos visibles, habilitados y seleccionables dentro de un área especificada de la escena.

Véase también « isSelected()» y « QGraphicsScene::selectedItems()».

void QGraphicsItem::setToolTip(const QString &toolTip)

Establece la descripción emergente del elemento en toolTip. Si toolTip está vacío, se borra la descripción emergente del elemento.

Véase también toolTip() y QToolTip.

void QGraphicsItem::setTransform(const QTransform &matrix, bool combine = false)

Establece la matriz de transformación actual del elemento 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.

Para simplificar la interacción con los elementos mediante una vista transformada, QGraphicsItem proporciona las funciones mapTo... y mapFrom... que permiten realizar la conversión entre las coordenadas de los elementos y las de la escena. Por ejemplo, puedes llamar a mapToScene() para asignar una coordenada de un elemento a una coordenada de la escena, o a mapFromScene() para asignar una coordenada de la escena a una coordenada de un elemento.

La matriz de transformación se combina con las funciones rotation(), scale() y transformations() del elemento para formar una transformación combinada que asigna el sistema de coordenadas del elemento al de su padre.

Véase también transform(), setRotation(), setScale(), setTransformOriginPoint(), «El sistema de coordenadas de la vista gráfica» y Transformations.

void QGraphicsItem::setTransformOriginPoint(const QPointF &origin)

Establece el punto « origin » para la transformación en coordenadas del elemento.

Véase también « transformOriginPoint()» y « Transformations ».

void QGraphicsItem::setTransformOriginPoint(qreal x, qreal y)

Establece el punto de origen de la transformación en coordenadas del elemento. Esto equivale a llamar a la función setTransformOriginPoint(QPointF(x, y)).

Se trata de una función sobrecargada.

Véase también setTransformOriginPoint() y Transformations.

void QGraphicsItem::setTransformations(const QList<QGraphicsTransform *> &transformations)

Establece una lista de gráficos transformations (QGraphicsTransform) que se aplican actualmente a este elemento.

Si lo único que quieres es rotar o escalar un elemento, deberías llamar a setRotation() o setScale() en su lugar. Si quieres establecer una transformación arbitraria en un elemento, puedes llamar a setTransform().

QGraphicsTransform sirve para aplicar y controlar una cadena de operaciones de transformación individuales sobre un elemento. Resulta especialmente útil en animaciones, donde cada operación de transformación debe interpolarse de forma independiente o diferente.

Las transformaciones se combinan con los métodos rotation(), scale() y transform() del elemento para mapear el sistema de coordenadas del elemento al del elemento padre.

Véanse también transformations(), scale(), setTransformOriginPoint() y Transformations.

void QGraphicsItem::setVisible(bool visible)

Si visible es verdadero, el elemento se hace visible. De lo contrario, el elemento se hace invisible. Los elementos invisibles no se dibujan ni reciben ningún evento. En concreto, los eventos del ratón atraviesan los elementos invisibles y se transmiten a cualquier elemento que pueda encontrarse detrás. Los elementos invisibles tampoco se pueden seleccionar, no pueden recibir el foco de entrada y no son detectados por las funciones de localización de elementos de QGraphicsScene.

Si un elemento se vuelve invisible mientras tiene el control del ratón (es decir, mientras está recibiendo eventos del ratón), perderá automáticamente dicho control, y este no se recuperará al volver a hacer visible el elemento; deberá recibir una nueva pulsación del ratón para recuperar el control.

Del mismo modo, un elemento invisible no puede tener el foco, por lo que si el elemento tiene el foco cuando se vuelve invisible, lo perderá, y el foco no se recupera simplemente volviendo a hacer visible el elemento.

Si se oculta un elemento padre, todos sus elementos hijos también quedarán ocultos. Si se muestra un elemento padre, se mostrarán todos los elementos hijos, a menos que se hayan ocultado explícitamente (es decir, si se llama a setVisible(false) en un elemento hijo, este no volverá a mostrarse aunque su elemento padre esté oculto y luego se vuelva a mostrar).

Los elementos son visibles por defecto; no es necesario llamar a setVisible() en un elemento nuevo.

Nota: Un elemento con la opacidad establecida en 0 seguirá considerándose visible, aunque se tratará como un elemento invisible: los eventos del ratón lo atravesarán, no se incluirá en los elementos devueltos por ` QGraphicsView::items()` y así sucesivamente. Sin embargo, el elemento conservará el foco.

Véanse también isVisible(), show(), hide() y setOpacity().

void QGraphicsItem::setX(qreal x)

Establece la coordenada x de la posición del elemento. Equivale a llamar a setPos(x, y()).

Véase también x() y setPos().

void QGraphicsItem::setY(qreal y)

Establece la coordenada « y » de la posición del elemento. Equivale a llamar a « setPos » (x(), y).

Véase también y(), x() y setPos().

void QGraphicsItem::setZValue(qreal z)

Establece el valor Z del elemento en z. El valor Z determina el orden de superposición de los elementos hermanos (adyacentes). Un elemento hermano con un valor Z más alto siempre se mostrará por encima de otro elemento hermano con un valor Z más bajo.

Si restableces el valor Z, el orden de inserción del elemento determinará su orden de superposición.

El valor Z no afecta en modo alguno al tamaño del elemento.

El valor Z por defecto es 0.

Véase también zValue(), Sorting, stackBefore() y ItemStacksBehindParent.

[virtual] QPainterPath QGraphicsItem::shape() const

Devuelve la forma de este elemento como un objeto ` QPainterPath ` en coordenadas locales. La forma se utiliza para muchas cosas, entre ellas la detección de colisiones, las pruebas de impacto y las funciones ` QGraphicsScene::items()`.

La implementación predeterminada llama a ` boundingRect()` para devolver una forma rectangular simple, pero las subclases pueden reimplementar esta función para devolver una forma más precisa en el caso de elementos no rectangulares. Por ejemplo, un elemento redondo puede optar por devolver una forma elíptica para mejorar la detección de colisiones. Por ejemplo:

QPainterPath RoundItem::shape() const
{
    QPainterPath path;
    path.addEllipse(boundingRect());
    return path;
}

El contorno de una forma puede variar en función del grosor y el estilo del lápiz utilizado al dibujar. Si deseas incluir este contorno en la forma del elemento, puedes crear una forma a partir del trazo utilizando QPainterPathStroker.

Esta función es invocada por las implementaciones predeterminadas de contains() y collidesWithPath().

Véase también ` boundingRect()`, ` contains()`, ` prepareGeometryChange()` y ` QPainterPathStroker`.

void QGraphicsItem::show()

Muestra el elemento (los elementos están visibles por defecto).

Esta función de conveniencia equivale a llamar a setVisible(true).

Véanse también hide() y setVisible().

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Coloca este elemento antes de « sibling », lo que significa que este elemento se mostrará detrás del elemento hermano. En otras palabras, el elemento hermano aparecerá visualmente encima de este elemento.

Los dos elementos deben ser hermanos (es decir, deben compartir el mismo elemento padre o ambos deben ser elementos de nivel superior). El ` sibling ` debe tener el mismo valor Z que este elemento; de lo contrario, llamar a esta función no tendrá ningún efecto.

Por defecto, todos los elementos hermanos se apilan según el orden de inserción (es decir, el primer elemento que se añada se dibuja antes que el siguiente). Si los valores Z de dos elementos son diferentes, el elemento con el valor Z más alto se dibuja encima. Cuando los valores Z son iguales, el orden de inserción determinará el orden de apilamiento.

Véase también setZValue(), ItemStacksBehindParent y Sorting.

QGraphicsObject *QGraphicsItem::toGraphicsObject()

Devuelve el elemento gráfico convertido a un ` QGraphicsObject`, si la clase es realmente un objeto gráfico; en caso contrario, devuelve 0.

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

Devuelve el elemento gráfico convertido a un ` QGraphicsObject`, si la clase es realmente un objeto gráfico; en caso contrario, devuelve 0.

QString QGraphicsItem::toolTip() const

Devuelve la descripción emergente del elemento o un objeto ` QString ` vacío si no se ha establecido ninguna descripción emergente.

Véase también setToolTip() y QToolTip.

QGraphicsItem *QGraphicsItem::topLevelItem() const

Devuelve el elemento de nivel superior de este elemento. El elemento de nivel superior es el elemento antecesor más alto del elemento cuyo padre es nullptr. Si un elemento no tiene padre, se devuelve su propio puntero (es decir, un elemento de nivel superior es su propio elemento de nivel superior).

Véase también parentItem().

QGraphicsWidget *QGraphicsItem::topLevelWidget() const

Devuelve un puntero al widget de nivel superior del elemento (es decir, el antepasado del elemento cuyo padre es nullptr, o cuyo padre no es un widget), o nullptr si este elemento no tiene un widget de nivel superior. Si el elemento es su propio widget de nivel superior, esta función devuelve un puntero al propio elemento.

QTransform QGraphicsItem::transform() const

Devuelve la matriz de transformación de este elemento.

La matriz de transformación se combina con los valores de « rotation()», « scale()» y « transformations()» del elemento para formar una transformación combinada del mismo.

La matriz de transformación por defecto es una matriz identidad.

Véanse también setTransform() y sceneTransform().

QPointF QGraphicsItem::transformOriginPoint() const

Devuelve el punto de origen de la transformación en coordenadas del elemento.

El valor por defecto es QPointF(0,0).

Véase también setTransformOriginPoint() y Transformations.

QList<QGraphicsTransform *> QGraphicsItem::transformations() const

Devuelve una lista de transformaciones gráficas que se aplican actualmente a este elemento.

QGraphicsTransform Sirve para aplicar y controlar una cadena de operaciones de transformación individuales sobre un elemento. Resulta especialmente útil en animaciones, donde cada operación de transformación debe interpolarse de forma independiente o diferente.

Las transformaciones se combinan con las funciones ` rotation()`, ` scale()` y ` transform()` del elemento para asignar el sistema de coordenadas del elemento al elemento padre.

Véanse también setTransformations(), scale(), rotation(), transformOriginPoint() y Transformations.

[virtual] int QGraphicsItem::type() const

Devuelve el tipo de un elemento como un entero. Todas las clases estándar de elementos gráficos están asociadas a un valor único; véase QGraphicsItem::Type. Esta información sobre el tipo la utiliza qgraphicsitem_cast() para distinguir entre tipos.

La implementación por defecto (en QGraphicsItem) devuelve UserType.

Para poder utilizar qgraphicsitem_cast() con un elemento personalizado, reimplemente esta función y declare un valor de la enumeración Type igual al tipo de su elemento personalizado. Los elementos personalizados deben devolver un valor mayor o igual que UserType (65536).

Por ejemplo:

class Item : public QGraphicsItem
{
public:
   enum { Type = UserType + 1 };

   int type() const override
   {
       // Enable the use of qgraphicsitem_cast with this item.
       return Type;
   }
   //...
};

Véase también UserType.

void QGraphicsItem::ungrabKeyboard()

Libera el bloqueo del teclado.

Véase también grabKeyboard() y ungrabMouse().

void QGraphicsItem::ungrabMouse()

Suelta el botón del ratón.

Véase también grabMouse() y ungrabKeyboard().

void QGraphicsItem::unsetCursor()

Elimina el cursor de este elemento.

Véase también hasCursor() y setCursor().

void QGraphicsItem::update(const QRectF &rect = QRectF())

Programa un redibujado del área cubierta por rect en este elemento. Puedes llamar a esta función siempre que sea necesario redibujar el elemento, por ejemplo, si cambia su aspecto o su tamaño.

Esta función no provoca un repintado inmediato; en su lugar, programa una solicitud de repintado que es procesada por QGraphicsView una vez que el control llega al bucle de eventos. El elemento solo se volverá a dibujar si está visible en alguna vista asociada.

Como efecto secundario del redibujado del elemento, es posible que también se redibujen otros elementos que se superpongan al área rect.

Si el elemento es invisible (es decir, si isVisible() devuelve false), esta función no realiza ninguna acción.

Véanse también paint() y boundingRect().

void QGraphicsItem::update(qreal x, qreal y, qreal width, qreal height)

Esta función de conveniencia equivale a llamar a `update(QRectF(x, y, width, height))`.

Se trata de una función sobrecargada.

[protected] void QGraphicsItem::updateMicroFocus()

Actualiza el microenfoque del elemento.

Véase también QInputMethod.

[virtual protected] void QGraphicsItem::wheelEvent(QGraphicsSceneWheelEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse para recibir eventos de rueda para este elemento. Si reimplementas esta función, se aceptará por defecto el valor « event ».

Si ignora el evento (es decir, llamando a ` QEvent::ignore()`), este se propagará a cualquier elemento situado debajo de este. Si ningún elemento acepta el evento, la escena lo ignorará y se propagará a la vista (por ejemplo, a la barra de desplazamiento vertical de la vista).

La implementación por defecto ignora el evento.

Véase también sceneEvent().

QGraphicsWidget *QGraphicsItem::window() const

Devuelve la ventana del elemento o ` nullptr ` si dicho elemento no tiene ventana. Si el elemento es una ventana, devolverá el propio elemento. En caso contrario, devolverá el antepasado más cercano que sea una ventana.

Véase también QGraphicsWidget::isWindow().

qreal QGraphicsItem::x() const

Esta función de conveniencia equivale a llamar a pos().x().

Véanse también setX() y y().

qreal QGraphicsItem::y() const

Esta función de conveniencia equivale a llamar a pos().y().

Véase también setY() y x().

qreal QGraphicsItem::zValue() const

Devuelve el valor Z del elemento. El valor Z influye en el orden de superposición de los elementos hermanos (adyacentes).

El valor Z por defecto es 0.

Véase también setZValue(), Sorting, stackBefore() y ItemStacksBehindParent.

Elementos no miembros relacionados

template <typename T> T qgraphicsitem_cast(QGraphicsItem *item)

Devuelve el objeto ` item ` dado, convertido al tipo `T`, si ` item ` es de tipo `T`; en caso contrario, se devuelve ` nullptr `.

Nota: Para que esta función funcione correctamente con elementos personalizados, reimplementa la función type() para cada subclase personalizada de QGraphicsItem.

Véase también QGraphicsItem::type() y QGraphicsItem::UserType.

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