QGraphicsItem Class

Documentación de la función miembro

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

Construye un QGraphicsItem con el elemento parent dado. 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 se convertirá entonces en un elemento de nivel superior.

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

[virtual noexcept] QGraphicsItem::~QGraphicsItem()

Destruye el QGraphicsItem y todos sus hijos. Si este ítem está actualmente asociado a una escena, el ítem será eliminado de la escena antes de ser borrado.

bool QGraphicsItem::acceptDrops() const

Devuelve true si este elemento puede aceptar eventos de arrastrar y soltar; en caso contrario, devuelve false. Por defecto, los ítems no aceptan eventos de arrastrar y soltar; los ítems son transparentes al arrastrar y soltar.

Véase también setAcceptDrops().

bool QGraphicsItem::acceptHoverEvents() const

Devuelve true si un elemento acepta eventos hover (QGraphicsSceneHoverEvent); en caso contrario, devuelve false. Por defecto, los elementos no aceptan eventos hover.

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

bool QGraphicsItem::acceptTouchEvents() const

Devuelve true si un elemento acepta touch events; en caso contrario, devuelve false. Por defecto, los elementos no aceptan 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 receptor del ratón cuando se produzca un evento de pulsación del ratón para ese botón. Sin embargo, si el elemento no acepta el botón, QGraphicsScene reenviará los eventos de ratón al primer elemento situado debajo que sí lo acepte.

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

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

Esta función virtual es llamada dos veces para todos los ítems por la ranura QGraphicsScene::advance(). En la primera fase, todos los ítems son llamados con phase == 0, indicando que los ítems en la escena están a punto de avanzar, y luego todos los ítems son llamados con phase == 1. Reimplemente esta función para actualizar su elemento si necesita una animación simple controlada por la escena.

La implementación por defecto no hace nada.

Esta función está pensada para animaciones. Una alternativa es heredar múltiples funciones de QObject y QGraphicsItem y utilizar la estructura de animación.

Ver 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; toda pintura debe restringirse al interior del rectángulo delimitador de un elemento. QGraphicsView utiliza esto para determinar si el elemento requiere ser redibujado.

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

Si quieres cambiar el rectángulo delimitador del elemento, primero debes llamar a prepareGeometryChange(). Esto notifica a la escena del cambio inminente, para que pueda actualizar su índice de geometría del elemento; de lo contrario, la escena no será consciente de la nueva geometría del elemento, y los resultados son indefinidos (por lo general, los artefactos de renderizado se dejan dentro de la vista).

Reimplemente esta función para permitir que QGraphicsView determine qué partes del widget, si las hay, necesitan ser redibujadas.

Nota: Para las formas que pintan un contorno / trazo, es importante incluir la mitad del ancho del lápiz en el rectángulo delimitador. Sin embargo, no es necesario compensar el antialiasing.

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 pasa una identidad QTransform como parámetro, esta función devolverá una región de coordenadas local.

La región delimitadora describe un contorno aproximado del contenido visual del elemento. Aunque su cálculo es costoso, también es más preciso que boundingRect(), y puede ayudar a evitar repintados innecesarios cuando se actualiza un elemento. Esto es particularmente eficaz para elementos finos (por ejemplo, líneas o polígonos simples). Puede ajustar la granularidad de la región delimitadora llamando a setBoundingRegionGranularity(). La granularidad por defecto es 0, en la que la región de delimitación del elemento es la misma que su rectángulo de delimitación.

itemToDeviceTransform es la transformación de las coordenadas del elemento a las coordenadas del dispositivo. Si desea que esta función devuelva un QRegion en coordenadas de escena, puede 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 entre 0 y 1. El valor predeterminado es 0 (es decir, la granularidad más baja, en la que la región delimitadora corresponde al 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 por defecto es NoCache (es decir, la caché está desactivada y todo el pintado es inmediato).

Véase también setCacheMode().

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

Devuelve una lista de los hijos de este elemento.

Los elementos se ordenan por orden de apilamiento. Esto tiene 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, sus hijos, etc.) en coordenadas locales. El rectángulo contendrá a todos los descendientes después de haber sido mapeados a coordenadas locales. Si el elemento no tiene hijos, esta función devuelve un QRectF vacío.

Esto no incluye el propio rectángulo delimitador de este elemento; sólo devuelve el rectángulo delimitador acumulado de sus descendientes. Si necesita incluir el recto delimitador de este elemento, puede añadir boundingRect() a childrenBoundingRect() utilizando QRectF::operator|().

Esta función es lineal en complejidad; determina el tamaño del rectángulo delimitador devuelto iterando a través de todos los descendientes.

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

void QGraphicsItem::clearFocus()

Toma el foco de entrada de teclado del elemento.

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

Sólo los elementos que establecen la bandera ItemIsFocusable, o los widgets que establecen una política de foco apropiada, 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 QPainterPath vacío si este 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 dibujar y recibir eventos).

Puede activar el recorte activando los indicadores ItemClipsToShape o ItemClipsChildrenToShape. La ruta de recorte del elemento se calcula intersecando todas las formas de los ancestros de recorte. Si el elemento establece ItemClipsToShape, el recorte final se intersecta con la propia forma del elemento.

Véase 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.

mode se aplica a other, y la forma o rectángulo resultante se compara con la forma de este elemento. El valor por defecto para mode es Qt::IntersectsItemShape; other colisiona con este elemento si interseca, contiene o está contenido por la forma de este elemento (ver 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. Debido a que la complejidad de la intersección arbitraria forma-forma crece con un orden de magnitud cuando las formas son complejas, esta operación puede consumir mucho tiempo. Tiene la opción de reimplementar esta función en una subclase de QGraphicsItem para proporcionar un algoritmo personalizado. Esto le permite hacer uso de las restricciones naturales en las formas de sus propios elementos, con el fin de mejorar el rendimiento de la detección de colisiones. Por ejemplo, la colisión de dos objetos perfectamente circulares sin transformar puede determinarse muy eficazmente comparando sus posiciones y radios.

Tenga en cuenta que cuando reimplemente esta función y llame a shape() o boundingRect() en other, las coordenadas devueltas deben ser mapeadas al sistema de coordenadas de este ítem antes de que cualquier intersección pueda tener lugar.

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

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

Devuelve true si este elemento colisiona con path.

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

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

Véase 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, la forma o el rectángulo delimitador de cada elemento se comprueba con 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 ancestro común más cercano de este elemento y other, o nullptr si other es nullptr, o no hay ancestro 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 llama más a menudo desde QGraphicsView para determinar qué elemento está bajo el cursor, y por esa razón, la implementación de esta función debería 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éase también shape(), boundingRect(), y collidesWithPath().

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

Este manejador de eventos puede ser reimplementado en una subclase para procesar eventos del menú contextual. El parámetro event contiene detalles sobre el evento a tratar.

Si ignoras el evento (es decir, llamando a QEvent::ignore()), event se propagará a cualquier elemento que se encuentre debajo de este elemento. Si ningún elemento acepta el evento, será ignorado por la escena y se propagará a la vista.

Es habitual abrir un QMenu en respuesta a la recepción de un evento de 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 por defecto 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 esté sobre este elemento. Consulte list of predefined cursor objects para ver una serie de formas útiles.

Un elemento del editor puede querer usar un cursor en forma de I:

item->setCursor(Qt::IBeamCursor);

Si no se ha establecido ningún cursor, se utilizará el cursor del elemento situado debajo.

Véase 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 QVariant.

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

static const int ObjectName = 0;

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

Qt no utiliza esta característica para almacenar datos; se proporciona únicamente para la comodidad del usuario.

Véase también setData().

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

Devuelve la matriz de transformación de dispositivo de este elemento, utilizando viewportTransform para asignar coordenadas de escena a coordenadas de dispositivo. Esta matriz se puede utilizar para asignar coordenadas y formas geométricas desde el sistema de coordenadas local de este elemento al sistema de coordenadas de la ventana gráfica (o de cualquier dispositivo). Para asignar coordenadas desde la ventana gráfica, primero debe 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 es la misma que combinar la transformada de escena de este elemento con la transformada de la vista, pero también entiende la bandera ItemIgnoresTransformations. La transformada de dispositivo puede utilizarse para realizar un mapeado de coordenadas preciso (y detección de colisiones) para elementos no transformables.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de arrastre de este ítem. Los eventos de arrastre se generan cuando el cursor entra en el área del elemento.

Al aceptar el evento (es decir, llamando a QEvent::accept()), el ítem aceptará eventos drop, además de recibir drag move y drag leave. En caso contrario, el evento será ignorado y se propagará al elemento situado debajo. Si el evento es aceptado, el elemento recibirá un evento de movimiento de arrastre antes de que el control vuelva al bucle de eventos.

Una implementación común de dragEnterEvent acepta o ignora event dependiendo 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 por defecto; para activar esta función, llame a setAcceptDrops(true).

La implementación por defecto no hace nada.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de arrastre para este ítem. Los eventos drag leave se generan cuando el cursor abandona el área del ítem. La mayoría de las veces no necesitarás reimplementar esta función, pero puede ser útil para restablecer el estado de tu elemento (por ejemplo, resaltado).

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

Los elementos no reciben eventos de arrastrar y soltar por defecto; para activar esta función, llame a setAcceptDrops(true).

La implementación por defecto no hace nada.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de movimiento de arrastre para este ítem. Los eventos de arrastre se generan cuando el cursor se mueve dentro del área del ítem. La mayoría de las veces no necesitarás reimplementar esta función; se utiliza para indicar que sólo partes del ítem pueden aceptar drops.

Llamar a QEvent::ignore() o QEvent::accept() en event cambia si el ítem aceptará o no drops en la posición del evento. Por defecto, event es aceptado, indicando que el ítem permite drops en la posición especificada.

Los ítems no reciben eventos de arrastrar y soltar por defecto; para activar esta característica, llama a setAcceptDrops(true).

La implementación por defecto no hace nada.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de caída para este ítem. Los elementos sólo pueden recibir eventos de soltar si el último evento de movimiento de arrastre fue aceptado.

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

Los ítems no reciben eventos de arrastrar y soltar por defecto; para activar esta característica, llama a setAcceptDrops(true).

La implementación por defecto no hace nada.

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

qreal QGraphicsItem::effectiveOpacity() const

Devuelve la opacidad efectiva de este elemento, que está entre 0.0 (transparente) y 1.0 (opaco). Este valor es una combinación de la opacidad local de este elemento, y las opacidades de sus padres y ancestros. La opacidad efectiva decide 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 QGraphicsView, esta función intentará desplazar la vista para asegurarse de que rect es visible dentro de la ventana gráfica de la vista. Si rect es un rectángulo nulo (por defecto), QGraphicsItem será 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 alcanzar el rectángulo especificado, el contenido se desplaza a la posición válida más cercana.

Si este elemento no se visualiza en QGraphicsView, esta función no hace nada.

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 es equivalente a llamar a ensureVisible(QRectF(x, y, w, h), xmargin, ymargin).

bool QGraphicsItem::filtersChildEvents() const

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

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

Véase también setFiltersChildEvents().

QGraphicsItem::GraphicsItemFlags QGraphicsItem::flags() const

Devuelve las banderas de este elemento. Las banderas describen qué características configurables del elemento están habilitadas y cuáles no. Por ejemplo, si las banderas incluyen ItemIsFocusable, el elemento puede aceptar el foco de entrada.

Por defecto, no se activa ninguna bandera.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir foco en eventos para este ítem. La implementación por defecto llama a ensureVisible().

Ver también focusOutEvent(), sceneEvent(), y setFocus().

QGraphicsItem *QGraphicsItem::focusItem() const

Si este elemento, un hijo o descendiente de este elemento tiene actualmente el foco de entrada, esta función devolverá un puntero a ese 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 manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de focus out para este ítem. La implementación por defecto no hace nada.

Ver también focusInEvent(), sceneEvent(), y setFocus().

QGraphicsItem *QGraphicsItem::focusProxy() const

Devuelve el proxy de enfoque de este elemento, o nullptr si este elemento no tiene proxy de enfoque.

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

void QGraphicsItem::grabKeyboard()

Toma la entrada del teclado.

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

• El elemento se vuelve invisible
• El elemento se elimina de la escena
• El elemento se elimina
• 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 recupera el control del teclado, recibe un evento QEvent::GrabKeyboard. Cuando pierde el control del teclado, recibe un evento QEvent::UngrabKeyboard. Estos eventos se pueden utilizar para detectar cuando un elemento obtiene o pierde el control del teclado por otros medios que no sean la obtención del foco de entrada.

Casi nunca es necesario agarrar explícitamente el teclado en Qt, ya que Qt lo agarra y lo suelta de forma sensible. En particular, Qt agarra el teclado cuando tu elemento obtiene el foco de entrada, y lo libera cuando tu elemento pierde el foco de entrada, o cuando el elemento se oculta.

Ten en cuenta que sólo los elementos visibles pueden tomar la entrada del teclado. Llamar a grabKeyboard() en un elemento invisible no tiene ningún efecto.

Los eventos de teclado no se ven afectados.

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

void QGraphicsItem::grabMouse()

Toma la entrada del ratón.

Este elemento recibirá todos los eventos de ratón de la escena hasta que ocurra alguno de los siguientes eventos:

• El elemento se vuelve invisible
• El elemento se elimina de la escena
• El elemento se elimina
• El ítem 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 recupera el agarre del ratón, recibe un evento QEvent::GrabMouse. Cuando pierde el agarre del ratón, recibe un evento QEvent::UngrabMouse. Estos eventos pueden ser usados para detectar cuando un ítem gana o pierde el agarre del ratón a través de otros medios que no sean la recepción de eventos del botón del ratón.

Casi nunca es necesario agarrar explícitamente el ratón en Qt, ya que Qt lo agarra y lo suelta de forma sensible. En particular, Qt agarra el ratón cuando pulsas un botón del ratón, y lo mantiene agarrado hasta que sueltas el último botón del ratón. Además, los widgets de Qt::Popup llaman implícitamente a grabMouse() cuando se muestran, y a ungrabMouse() cuando se ocultan.

Ten en cuenta que sólo 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 es miembro 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 estándar.

Véase también unsetCursor().

bool QGraphicsItem::hasFocus() const

Devuelve true si este elemento está activo, y él o su focus proxy tiene 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 son visibles por defecto).

Esta función es equivalente a llamar a setVisible(false).

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos hover enter para este ítem. La implementación por defecto llama a update(); en caso contrario no hace nada.

Llamar a QEvent::ignore() o 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 manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de hover leave para este item. La implementación por defecto llama a update(); en caso contrario no hace nada.

Llamar a QEvent::ignore() o 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 manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de movimiento hover para este item. La implementación por defecto no hace nada.

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

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos del método de entrada para este elemento. La implementación por defecto ignora el evento.

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

Qt::InputMethodHints QGraphicsItem::inputMethodHints() const

Devuelve los consejos sobre el método de entrada de este elemento.

Las sugerencias del método de entrada sólo son relevantes para los elementos de entrada. Las sugerencias son utilizadas por el método de entrada para indicar cómo debe operar. Por ejemplo, si el indicador Qt::ImhNumbersOnly está activado, el método de entrada puede cambiar sus componentes visuales para reflejar que sólo se pueden introducir números.

El efecto puede variar entre implementaciones de métodos de entrada.

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

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

Este método sólo es relevante para los elementos de entrada. Es utilizado por el método de entrada para consultar un conjunto de propiedades del elemento para poder soportar operaciones complejas del método de entrada, como soporte para texto circundante y 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, haciendo que todos los eventos para este elemento pasen primero a través de filterItem's sceneEventFilter() function.

Para filtrar los eventos de otro elemento, instala este elemento como un filtro de eventos para el 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 ítem sólo puede filtrar eventos de otros ítems en la misma escena. Además, un ítem no puede filtrar sus propios eventos; en su lugar, puedes reimplementar sceneEvent() directamente.

Los ítems deben pertenecer a una escena para que los filtros de eventos de escena puedan ser instalados y utilizados.

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 sólo puede estar activo si la escena está activa. Un elemento está activo si es, o es descendiente de, un panel activo. Los elementos de paneles no activos no están activos.

Los elementos que no forman parte de un panel siguen a la activación de la escena cuando ésta no tiene un panel activo.

Sólo los elementos activos pueden obtener el foco de entrada.

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

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

Devuelve true si este elemento es un antepasado de child (es decir, si este elemento es el padre de child o uno de los antepasados del padre 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, false en caso contrario. Si blockingPanel es distinto de cero, blockingPanel se asignará al 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 están en una escena.

Ver también panelModality(), setPanelModality(), y PanelModality.

bool QGraphicsItem::isClipped() const

Devuelve true si este elemento está recortado. Un elemento está recortado si ha establecido el indicador ItemClipsToShape, o si él mismo o alguno de sus ancestros ha establecido el indicador ItemClipsChildrenToShape.

El recorte afecta a la apariencia del elemento (es decir, al pintado), así como a la entrega de eventos de ratón y hover.

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 está completamente oscurecido por la forma opaca de cualquiera de los elementos que colisionan por encima de él (es decir, con un valor Z mayor que este elemento).

Véase también opaqueArea().

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

Esta función es equivalente a llamar a isObscured(QRectF(x, y, w, h)).

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

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

La implementación base mapea item's opaqueArea() al sistema de coordenadas de este elemento, y luego comprueba si el boundingRect() de este elemento está completamente contenido dentro de la forma mapeada.

Puedes reimplementar esta función para proporcionar un algoritmo personalizado para determinar si este elemento está oculto por item.

Véase 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 están en un grupo heredan el estado seleccionado 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 una de las vistas; en caso contrario, 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.

Tenga en cuenta que la visibilidad general del elemento no está relacionada con el hecho de que esté siendo visualizado o no por 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 devolverá si el elemento es visible para la escena o no.

Un elemento puede no ser visible para sus ancestros incluso si isVisible() es verdadero. También puede ser visible para sus ancestros incluso si isVisible() es falso. Si algún ancestro está oculto, el propio elemento estará implícitamente oculto, en cuyo caso esta función devolverá false.

Véase 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)

Esta función virtual es llamada por QGraphicsItem para notificar a los elementos personalizados que alguna parte del estado del elemento cambia. Al reimplementar esta función, se puede 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 hace nada, y devuelve value.

Nota: Algunas funciones de QGraphicsItem no pueden invocarse en una reimplementación de esta función; consulte 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 un QTransform que mapea las coordenadas de este elemento a other. Si ok no es nulo, y si no existe tal transformación, el booleano apuntado por ok se establecerá en false; en caso contrario, se establecerá en true.

Esta transformación proporciona una alternativa a las funciones mapToItem() o mapFromItem(), devolviendo la transformación apropiada para que usted mismo pueda mapear formas y coordenadas. También le ayuda a escribir un código más eficiente cuando se repite la asignación entre los mismos dos elementos.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de pulsación de teclas para este elemento. La implementación por defecto ignora el evento. Si reimplementas este manejador, el evento será aceptado por defecto.

Tenga en cuenta que los eventos de pulsación de teclas sólo se reciben para los elementos que establecen la bandera ItemIsFocusable, y que tienen el foco de entrada de teclado.

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de liberación de teclas para este elemento. La implementación por defecto ignora el evento. Si reimplementas este manejador, el evento será aceptado por defecto.

Tenga en cuenta que los eventos de teclas sólo se reciben para los elementos que establecen la bandera ItemIsFocusable, y que tienen el foco de entrada del teclado.

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

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

Mapea la ruta path, que está en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve la ruta mapeada.

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

Mapea el punto point, que está en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.

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

Ver 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

Mapea el polígono polygon, que está en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el polígono mapeado.

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

Ver 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

Mapea el rectángulo rect, que está en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el rectángulo mapeado como un polígono.

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

Ver 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 es equivalente a llamar a mapFromItem(item, QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapFromItem(item, QPointF(x, y)).

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

Mapea la ruta path, que está en el sistema de coordenadas del padre de este elemento, al sistema de coordenadas de este elemento, y devuelve la ruta mapeada.

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

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

Mapea el punto point, que está en el sistema de coordenadas del padre de este elemento, al sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.

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

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

Mapea el polígono polygon, que está en el sistema de coordenadas del elemento padre, al sistema de coordenadas de este elemento, y devuelve el polígono mapeado.

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

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

Mapea el rectángulo rect, que está en el sistema de coordenadas del elemento padre, al sistema de coordenadas de este elemento, y devuelve el rectángulo mapeado como un polígono.

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

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

Esta función es equivalente a llamar a mapFromItem(QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapFromParent(QPointF(x, y)).

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

Mapea la ruta path, que está en el sistema de coordenadas de la escena de este elemento, al sistema de coordenadas de este elemento, y devuelve la ruta mapeada.

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

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

Mapea el punto point, que está en el sistema de coordenadas de la escena de este elemento, al sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.

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

Mapea el polígono polygon, que está en el sistema de coordenadas de la escena de este elemento, al sistema de coordenadas de este elemento, y devuelve el polígono mapeado.

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

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de la escena de este elemento, al sistema de coordenadas de este elemento, y devuelve el rectángulo mapeado como un polígono.

Ver 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 es equivalente a llamar a mapFromScene(QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapFromScene(QPointF(x, y)).

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de item, al sistema de coordenadas de este elemento, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapRectFromItem(item, QRectF(x, y, w, h)).

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

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

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

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

Esta función es equivalente a llamar a mapRectFromParent(QRectF(x, y, w, h)).

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

Mapea el rectángulo rect, que está en coordenadas de escena, al sistema de coordenadas de este elemento, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapRectFromScene(QRectF(x, y, w, h)).

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapRectToItem(item, QRectF(x, y, w, h)).

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de su padre, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapRectToParent(QRectF(x, y, w, h)).

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapRectToScene(QRectF(x, y, w, h)).

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

Mapea la ruta path, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve la ruta mapeada.

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

Ver 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

Mapea el punto point, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve la coordenada mapeada.

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

Ver 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

Mapea el polígono polygon, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el polígono mapeado.

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

Ver 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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de item, y devuelve el rectángulo mapeado como un polígono.

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

Ver 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 es equivalente a llamar a mapToItem(item, QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapToItem(item, QPointF(x, y)).

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

Mapea la ruta path, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de su padre, y devuelve la ruta mapeada. Si el ítem no tiene padre, path será mapeado 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

Mapea el punto point, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de su padre, y devuelve la coordenada mapeada. Si el ítem no tiene padre, point será mapeado al sistema de coordenadas de la escena.

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

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

Mapea el polígono polygon, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de su padre, y devuelve el polígono mapeado. Si el ítem no tiene padre, polygon será mapeado al sistema de coordenadas de la escena.

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

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de su padre, y devuelve el rectángulo mapeado como un polígono. Si el ítem no tiene padre, rect será mapeado al sistema de coordenadas de la escena.

Ver 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 es equivalente a llamar a mapToParent(QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapToParent(QPointF(x, y)).

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

Mapea el camino path, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el camino mapeado.

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

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

Mapea el punto point, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve la coordenada mapeada.

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

Mapea el polígono polygon, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el polígono mapeado.

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

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

Mapea el rectángulo rect, que está en el sistema de coordenadas de este elemento, al sistema de coordenadas de la escena, y devuelve el rectángulo mapeado 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 es equivalente a llamar a mapToScene(QRectF(x, y, w, h)).

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

Esta función es equivalente a llamar a mapToScene(QPointF(x, y)).

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de doble clic del ratón para este elemento.

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

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

La implementación por defecto llama a mousePressEvent(). Si quieres mantener la implementación base cuando reimplementes esta función, llama a QGraphicsItem::mouseDoubleClickEvent() en tu reimplementación.

Ten en cuenta que un ítem no recibirá eventos de doble click si no es ni selectable ni movable (los clicks simples de ratón son ignorados en este caso, y eso detiene la generación de dobles clicks).

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de movimiento del ratón para este ítem. Si recibe este evento, puede estar seguro de que este ítem también recibió un evento de pulsación de ratón, y que este ítem es el actual capturador del ratón.

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

La implementación por defecto maneja la interacción básica con los elementos, como la selección y el movimiento. Si quieres mantener la implementación base cuando reimplementes esta función, llama a QGraphicsItem::mouseMoveEvent() en tu reimplementación.

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

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de pulsación de ratón para este ítem. Los eventos de pulsación del ratón sólo se envían a los elementos que aceptan el botón del ratón que se pulsa. Por defecto, un ítem acepta todos los botones del ratón, pero puedes cambiar esto llamando a setAcceptedMouseButtons().

El evento de pulsación del ratón decide qué elemento debe convertirse en el capturador del ratón (ver QGraphicsScene::mouseGrabberItem()). Si no reimplementas esta función, el evento de pulsación se propagará a cualquier elemento situado por debajo de este elemento, y no se enviarán otros eventos de ratón a este elemento.

Si reimplementas esta función, event será aceptada por defecto (ver QEvent::accept()), y este elemento será entonces el que agarre el ratón. Esto permite al elemento recibir futuros eventos de mover, soltar y doble clic. Si se llama a QEvent::ignore() en event, este elemento perderá el control del ratón, y event se propagará a cualquier elemento situado por 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 de ratón.

La implementación por defecto maneja la interacción básica con los elementos, como la selección y el movimiento. Si quieres mantener la implementación base cuando reimplementes esta función, llama a QGraphicsItem::mousePressEvent() en tu reimplementación.

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

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

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de liberación del ratón para este ítem.

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

La implementación por defecto maneja la interacción básica con los ítems, como la selección y el movimiento. Si quieres mantener la implementación base cuando reimplementes esta función, llama a QGraphicsItem::mouseReleaseEvent() en tu reimplementación.

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

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

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

Desplaza el elemento dx puntos horizontalmente y dy puntos verticalmente. Esta función equivale a llamar a setPos(pos() + QPointF(dx, dy)).

qreal QGraphicsItem::opacity() const

Devuelve la opacidad local de este elemento, que está entre 0,0 (transparente) y 1,0 (opaco). Este valor se combina con los valores de los elementos padre y ancestro en effectiveOpacity(). La opacidad efectiva decide cómo se representa el elemento y también afecta a su visibilidad cuando es consultada por funciones como QGraphicsView::items().

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

La opacidad por defecto 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 donde este elemento es opaco. Un área es opaca si se rellena con un pincel o color opaco (es decir, no transparente).

Esta función es utilizada por isObscuredBy(), que es llamada por los elementos subyacentes para determinar si están oscurecidos 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 normalmente es llamada por QGraphicsView, pinta el contenido de un elemento en coordenadas locales.

Reimplemente esta función en una subclase de QGraphicsItem para proporcionar la implementación de pintura del elemento, utilizando painter. El parámetro option proporciona opciones de estilo para el elemento, como su estado, el área expuesta y sus sugerencias de nivel de detalle. El argumento widget es opcional. Si se proporciona, apunta al widget sobre el que se está pintando; en caso contrario, es 0. Para la pintura 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 es de ancho 0 por defecto, y su lápiz se inicializa con el pincel QPalette::Text de la paleta del dispositivo de pintura. El pincel se inicializa con QPalette::Window.

Asegúrese de restringir toda la pintura dentro de los límites de boundingRect() para evitar artefactos de renderizado (ya que QGraphicsView no recorta el pintor por usted). En particular, cuando QPainter renderiza el contorno de una forma usando un QPen asignado, la mitad del contorno se dibujará fuera, y la otra mitad dentro, de la forma que está renderizando (por ejemplo, con un ancho de lápiz de 2 unidades, debe dibujar contornos 1 unidad dentro de boundingRect()). QGraphicsItem no soporta el uso de lápices cosméticos con un ancho distinto de cero.

Todo el pintado se realiza en coordenadas locales.

Véase también setCacheMode(), QPen::width(), Item Coordinates, y ItemUsesExtendedStyleOption.

QGraphicsItem *QGraphicsItem::panel() const

Devuelve el panel del elemento, o nullptr si este elemento no tiene panel. Si el elemento es un panel, se devolverá a sí mismo. Si no, devolverá el ancestro 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 padre, se devuelve nullptr.

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

QGraphicsObject *QGraphicsItem::parentObject() const

Devuelve un puntero al elemento padre, convertido a QGraphicsObject. Devuelve nullptr si el elemento padre no es 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 es un widget.

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

QPointF QGraphicsItem::pos() const

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

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

Por comodidad, también puede llamar a scenePos() para determinar la posición del elemento en coordenadas de la escena, independientemente de su 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. Llame a esta función antes de cambiar 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 sobre este elemento de filterItem.

Véase también installSceneEventFilter().

void QGraphicsItem::resetTransform()

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

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

qreal QGraphicsItem::rotation() const

Devuelve la rotación en el sentido de las agujas del reloj, en grados, alrededor del eje Z. El valor por defecto es 0 (es decir, el elemento no se rota).

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

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

qreal QGraphicsItem::scale() const

Devuelve el factor de escala del ítem. El factor de escala por defecto es 1.0 (es decir, el elemento no se escala).

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

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

QGraphicsScene *QGraphicsItem::scene() const

Devuelve la escena actual para el elemento, o nullptr si el elemento no está almacenado en una escena.

Para añadir o mover un elemento a una escena, llame 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 eventos para este elemento. Reimplemente esta función para interceptar eventos antes de que sean enviados a los manejadores de eventos especializados contextMenuEvent(), focusInEvent(), focusOutEvent(), hoverEnterEvent(), hoverMoveEvent(), hoverLeaveEvent(), keyPressEvent(), keyReleaseEvent(), mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), y mouseDoubleClickEvent().

Devuelve true si el evento fue reconocido y manejado; en caso contrario, (por ejemplo, si el tipo de evento no fue reconocido) 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.

Reimplementar esta función en una subclase hace posible que el elemento sea utilizado como un filtro de eventos para otros elementos, interceptando todos los eventos enviados a esos elementos antes de que puedan responder.

Las reimplementaciones deben devolver true para evitar el procesamiento posterior de un evento dado, asegurando que no será entregado al elemento vigilado, o devolver false para indicar que el evento debe ser propagado posteriormente por el sistema de eventos.

Véase también installSceneEventFilter().

QPointF QGraphicsItem::scenePos() const

Devuelve la posición del elemento en coordenadas de escena. Esto es equivalente 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 la escena de este elemento. Esta matriz puede utilizarse para asignar coordenadas y formas geométricas desde el sistema de coordenadas local de este elemento al sistema de coordenadas de la escena. Para asignar coordenadas de la escena, primero debe 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 sólo devuelve la transformación local de un elemento, esta función incluye la posición del elemento (y de sus padres) y 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 por dx, dy. Si rect es un rectángulo nulo (por defecto), se desplaza el rectángulo delimitador del elemento.

El desplazamiento proporciona una alternativa rápida a simplemente redibujar cuando el contenido del elemento (o partes del elemento) se desplaza vertical u horizontalmente. Dependiendo de la transformación actual y de las capacidades del dispositivo de pintura (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 rerenderizar el área completa.

Después del desplazamiento, el elemento emitirá una actualización para las nuevas áreas expuestas. Si el desplazamiento no está soportado (por ejemplo, si se está renderizando a una vista OpenGL, que no se beneficia de las optimizaciones de desplazamiento), esta función es equivalente a llamar a update(rect).

Nota: El desplazamiento sólo está soportado cuando QGraphicsItem::ItemCoordinateCache está habilitado; en todos los demás casos, llamar a esta función es equivalente a llamar a update(rect). Si está seguro de que el elemento es opaco y no está superpuesto por otros elementos, puede asignar las coordenadas de rect a las coordenadas de la ventana gráfica y desplazar la ventana.

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 para los eventos de arrastrar y soltar. 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 hover; de lo contrario, los ignorará. Por defecto, los elementos no aceptan eventos hover.

Los eventos hover se envían cuando no hay ningún ítem que acepte el cursor del ratón. Se envían cuando el cursor del ratón entra en un elemento, cuando se mueve dentro del elemento y cuando el cursor sale de un elemento. Los eventos hover se suelen utilizar para resaltar un elemento cuando se entra en él, y para realizar un seguimiento del cursor del ratón cuando pasa por encima del elemento (equivalente a QWidget::mouseTracking).

Los elementos padre reciben eventos hover de entrada antes que sus hijos, y eventos de salida después que sus hijos. Sin embargo, el elemento padre no recibe un evento hover leave si el cursor entra en un elemento hijo; el elemento padre permanece "hovered" hasta que el cursor abandona su área, incluyendo las áreas de sus hijos.

Si un ítem padre maneja eventos hijo, recibirá eventos hover mover, arrastrar mover y soltar cuando el cursor pase a través de sus hijos, pero no recibe eventos hover entrar y hover salir, ni eventos arrastrar entrar y arrastrar salir en nombre de sus 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 ratón buttons para el que este elemento acepta eventos de ratón.

Por defecto, se aceptan todos los botones del ratón. Si un ítem acepta un botón del ratón, se convertirá en el ítem receptor del ratón cuando se envíe un evento de pulsación del 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 que sí lo acepte.

Para desactivar los eventos de ratón para un elemento (es decir, hacerlo transparente para los eventos de ratón), llame a setAcceptedMouseButtons(Qt::NoButton).

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

void QGraphicsItem::setActive(bool active)

Si active es verdadero, y la escena está activa, el panel de este elemento se activará. En caso contrario, el panel se desactivará.

Si el elemento no forma parte de una escena activa, active decidirá qué ocurre con el panel cuando la escena se active o el elemento se añada a la escena. Si es verdadero, 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 entre 0 y 1. El valor predeterminado es 0 (es decir, la granularidad más baja, en la que la región delimitadora corresponde al rectángulo delimitador del elemento).

boundingRegion() utiliza la granularidad para calcular el grosor de la región delimitadora del elemento. La granularidad más alta posible es 1, donde boundingRegion() devolverá el contorno más fino posible para el dispositivo respectivo (por ejemplo, para una ventana gráfica QGraphicsView, esto le da una región delimitadora de píxeles perfectos). 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 trozo corresponde a 4x4 unidades de 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 sólo es utilizado por el modo ItemCoordinateCache, y describe la resolución del búfer de caché; si logicalCacheSize es (100, 100), QGraphicsItem ajustará el elemento en 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 demás modos de caché distintos de ItemCoordinateCache, se ignora logicalCacheSize.

El almacenamiento en caché puede acelerar el renderizado si el elemento tarda mucho tiempo en redibujarse. En algunos casos la caché también puede ralentizar el renderizado, en particular cuando el elemento pasa menos tiempo redibujándose que el que QGraphicsItem pasa redibujándose desde la caché.

Cuando el almacenamiento en caché está activado, la función paint() de un elemento generalmente dibujará en una caché de mapa de píxeles fuera de la pantalla; para cualquier solicitud de repintado posterior, el marco de la Vista Gráfica 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 cambiar el límite de caché de QPixmapCache para obtener un rendimiento óptimo.

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

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 asumirá esta forma cuando esté sobre este elemento. Consulta list of predefined cursor objects para ver una serie de formas útiles.

Un elemento del editor puede querer usar un cursor en forma de I:

item->setCursor(Qt::IBeamCursor);

Si no se ha establecido ningún cursor, se utilizará el cursor del elemento situado debajo.

Véase 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 del elemento son útiles para almacenar propiedades arbitrarias para cualquier elemento. Qt no utiliza esta característica para almacenar datos; se proporciona únicamente para la comodidad del usuario.

Véase también data().

void QGraphicsItem::setEnabled(bool enabled)

Si enabled es verdadero, el elemento está habilitado; en caso contrario, está deshabilitado.

Los elementos desactivados son visibles, pero no reciben ningún evento, y no pueden tomar 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 si no acepta eventos del ratón (véase acceptedMouseButtons()). Un elemento deshabilitado no puede convertirse en el agarrador del ratón, y como resultado de esto, un elemento pierde el agarre si se deshabilita al agarrar el ratón, al igual que pierde el foco si tenía foco cuando estaba deshabilitado.

Los elementos desactivados se dibujan tradicionalmente utilizando colores grisáceos (ver QPalette::Disabled).

Si desactivas un elemento padre, todos sus hijos también se desactivarán. Si habilitas un elemento padre, todos los hijos se habilitarán, a menos que hayan sido explícitamente deshabilitados (es decir, si llamas a setEnabled(false) en un hijo, no se volverá a habilitar si su padre es deshabilitado, y luego habilitado de nuevo).

Los elementos están activados por defecto.

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); de lo contrario, si enabled es falso, este elemento sólo gestionará sus propios eventos. El valor por defecto es false.

Véase también filtersChildEvents().

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

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

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

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

Establece las banderas de los elementos en flags. Todas las banderas en flags están habilitadas; todas las banderas que no están en flags están deshabilitadas.

Si el ítem tenía foco y flags no habilita ItemIsFocusable, el ítem pierde el foco como resultado de llamar 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 se activa ninguna bandera. (QGraphicsWidget habilita la bandera ItemSendsGeometryChanges por defecto para seguir los cambios de posición).

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

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

Da el foco de entrada de teclado a este elemento. El argumento focusReason será pasado a cualquier focus event generado por esta función; se utiliza para dar una explicación de qué causó que el elemento obtuviera el foco.

Sólo los elementos activados que establecen la bandera ItemIsFocusable pueden aceptar el foco del teclado.

Si este elemento no es visible, no está activo o no está asociado a una escena, no obtendrá el foco de entrada inmediato. Sin embargo, se registrará como el elemento de foco preferido para su subárbol de elementos, en caso de que más tarde se haga 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, ese 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 enfoque del elemento en item.

Si un elemento tiene un proxy de foco, el proxy de foco recibirá el foco de entrada cuando el elemento obtenga el foco de entrada. El propio elemento seguirá teniendo el foco (es decir, hasFocus() devolverá true), pero sólo 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á manejada 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. Puede eliminar un efecto existente llamando a setGraphicsEffect(nullptr).

Si effect es el efecto instalado en un elemento diferente, setGraphicsEffect() eliminará el efecto del elemento y lo instalará en este elemento.

QGraphicsItem toma posesión de effect.

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 hijo del padre 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 de los elementos padre y ancestro en effectiveOpacity().

Por defecto, la opacidad se propaga de padre a hijo, de modo que si la opacidad de un padre es 0,5 y la de un hijo también es 0,5, la opacidad efectiva del hijo será 0,25.

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

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

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

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

Establece la modalidad de este elemento en panelModality.

Cambiar la modalidad de un elemento visible tiene efecto inmediato.

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 se convertirá en un elemento de nivel superior.

Ten en cuenta que esto añade implícitamente este elemento gráfico a la escena del padre. No se debe añadir el elemento a la escena en add.

El comportamiento cuando se llama a esta función en un elemento que es un ancestro de newParent es indefinido.

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

void QGraphicsItem::setPos(const QPointF &pos)

Establece la posición del elemento en pos, que está en coordenadas del elemento padre. Para elementos sin padre, pos está en coordenadas de escena.

La posición del elemento describe su origen (coordenada local (0, 0)) en coordenadas 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 es equivalente a llamar a setPos(QPointF(x, y)).

void QGraphicsItem::setRotation(qreal angle)

Establece la rotación en el sentido de las agujas del reloj angle, en grados, alrededor del eje Z. El valor por defecto es 0 (es decir, el elemento no rota). Si se asigna un valor negativo, el elemento girará en sentido contrario a las agujas del reloj. Normalmente el ángulo de rotación está en el rango (-360, 360), pero también es posible asignar valores fuera de este rango (por ejemplo, una rotación de 370 grados es lo mismo que una rotación de 10 grados).

El elemento se rota alrededor de su punto de origen de transformación, que por defecto es (0, 0). Puede seleccionar un origen de transformación diferente llamando a setTransformOriginPoint().

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

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

void QGraphicsItem::setScale(qreal factor)

Establece la escala factor del elemento. El factor de escala por defecto 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 proporciona un factor de escala negativo, el elemento se volteará y reflejará (es decir, girará 180 grados).

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

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

Véase también scale(), setTransformOriginPoint(), y Ejemplo de transformaciones.

void QGraphicsItem::setSelected(bool selected)

Si selected es verdadero y este elemento es seleccionable, este elemento se selecciona; de lo contrario, se deselecciona.

Si el elemento está en un grupo, el estado seleccionado de todo el grupo se conmuta mediante esta función. Si el grupo está seleccionado, todos los elementos del grupo también se seleccionan, y si el grupo no está seleccionado, no se selecciona ningún elemento del grupo.

Sólo pueden seleccionarse los elementos visibles, habilitados y seleccionables. Si selected es verdadero y este elemento es invisible o está deshabilitado o no se puede seleccionar, esta función no hace nada.

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

Esta función se proporciona por conveniencia, permitiendo la conmutación individual del estado seleccionado de un elemento. Sin embargo, una forma más común de seleccionar elementos es llamar a QGraphicsScene::setSelectionArea(), que llamará a esta función para todos los elementos visibles, habilitados y seleccionables dentro de un área especificada en la escena.

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

void QGraphicsItem::setToolTip(const QString &toolTip)

Establece la información sobre herramientas del elemento en toolTip. Si toolTip está vacío, se borra la información sobre herramientas 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 verdadero, entonces matrix se combina con la matriz actual; de lo contrario, matrix reemplaza la matriz actual. combine es falso por defecto.

Para simplificar la interacción con los elementos utilizando una vista transformada, QGraphicsItem proporciona funciones mapTo... y mapFrom... que pueden traducir entre las coordenadas de los elementos y las de la escena. Por ejemplo, puedes llamar a mapToScene() para convertir las coordenadas de un elemento en coordenadas de la escena, o a mapFromScene() para convertir las coordenadas de la escena en coordenadas del elemento.

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

Ver 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 de posición.

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 de elemento. Esto es equivalente a llamar a setTransformOriginPoint(QPointF(x, y)).

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 todo lo que quieres es rotar o escalar un elemento, deberías llamar a setRotation() o setScale() en su lugar. Si desea establecer una transformación arbitraria en un elemento, puede llamar a setTransform().

QGraphicsTransform es para aplicar y controlar una cadena de operaciones de transformación individuales sobre un elemento. Es particularmente útil en animaciones, donde cada operación de transformación necesita ser interpolada independientemente, o diferentemente.

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

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

void QGraphicsItem::setVisible(bool visible)

Si visible es verdadero, el elemento se hace visible. En caso contrario, se hace invisible. Los elementos invisibles no se pintan ni reciben eventos. En particular, los eventos del ratón pasan a través de los elementos invisibles, y son enviados a cualquier elemento que pueda estar detrás. Los elementos invisibles tampoco se pueden seleccionar, no pueden tomar el foco de entrada y no son detectados por las funciones de localización de elementos de QGraphicsScene.

Si un ítem se vuelve invisible mientras está siendo agarrado por el ratón (es decir, mientras está recibiendo eventos del ratón), perderá automáticamente el agarre del ratón, y el agarre no se recupera haciendo el ítem visible de nuevo; debe recibir una nueva pulsación del ratón para recuperar el agarre del ratón.

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

Si ocultas un elemento padre, todos sus hijos también se ocultarán. Si muestra un elemento padre, se mostrarán todos los hijos, a menos que se hayan ocultado explícitamente (es decir, si llama a setVisible(false) en un hijo, no se volverá a mostrar aunque se oculte su padre y luego se vuelva a mostrar).

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

Véase 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 decide el orden de apilamiento de los elementos hermanos (vecinos). Un elemento hermano con un valor Z alto siempre se dibujará encima de otro elemento hermano con un valor Z más bajo.

Si restablece el valor Z, el orden de inserción del elemento decidirá su orden de apilamiento.

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 QPainterPath en coordenadas locales. La forma se utiliza para muchas cosas, incluyendo la detección de colisiones, pruebas de impacto, y para las funciones QGraphicsScene::items().

La implementación por defecto llama a boundingRect() para devolver una forma rectangular simple, pero las subclases pueden reimplementar esta función para devolver una forma más precisa para elementos no rectangulares. Por ejemplo, un elemento redondo puede elegir devolver una forma elíptica para una mejor 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 de la anchura y el estilo del lápiz utilizado al dibujar. Si desea incluir este contorno en la forma del elemento, puede crear una forma a partir del trazo utilizando QPainterPathStroker.

Esta función es llamada por las implementaciones por defecto de contains() y collidesWithPath().

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

void QGraphicsItem::show()

Muestra el elemento (los elementos son visibles por defecto).

Esta función es equivalente a llamar a setVisible(true).

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

void QGraphicsItem::stackBefore(const QGraphicsItem *sibling)

Apila este elemento antes que sibling, lo que significa que este elemento se dibujará 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). sibling debe tener el mismo valor Z que este elemento, de lo contrario la llamada a esta función no tendrá ningún efecto.

Por defecto, todos los elementos hermanos se apilan por orden de inserción (es decir, el primer elemento que añades 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 decidirá el orden de apilamiento.

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

QGraphicsObject *QGraphicsItem::toGraphicsObject()

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

const QGraphicsObject *QGraphicsItem::toGraphicsObject() const

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

QString QGraphicsItem::toolTip() const

Devuelve el tool tip del elemento, o un QString vacío si no se ha establecido ningún tool tip.

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 ancestro superior 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 ancestro 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 rotation(), scale() y transformations() del elemento en transformaciones combinadas para el elemento.

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

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

QPointF QGraphicsItem::transformOriginPoint() const

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

Por defecto es QPointF(0,0).

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

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

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

QGraphicsTransform es para aplicar y controlar una cadena de operaciones de transformación individuales sobre un elemento. Es particularmente útil en animaciones, donde cada operación de transformación necesita ser interpolada independientemente, o de forma diferente.

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

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

[virtual] int QGraphicsItem::type() const

Devuelve el tipo de un elemento como un int. Todas las clases estándar de graphicsitem están asociadas a un valor único; véase QGraphicsItem::Type. Esta información de tipo es utilizada por qgraphicsitem_cast() para distinguir entre tipos.

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

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

Por ejemplo:

class CustomItem : 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 teclado.

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

void QGraphicsItem::ungrabMouse()

Libera el agarre del ratón.

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

void QGraphicsItem::unsetCursor()

Borra 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 tu elemento necesite ser redibujado, como por ejemplo si cambia de apariencia o tamaño.

Esta función no provoca un pintado inmediato, sino que programa una petición de pintado que es procesada por QGraphicsView después de que el control alcance el bucle de eventos. El elemento sólo se redibujará si es visible en cualquier vista asociada.

Como efecto secundario del repintado del elemento, otros elementos que se solapen con el área rect también pueden ser repintados.

Si el elemento es invisible (es decir, isVisible() devuelve false), esta función no hace nada.

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

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

Esta función es equivalente a llamar a update(QRectF(x, y, width, height)).

[protected] void QGraphicsItem::updateMicroFocus()

Actualiza el microenfoque del elemento.

Véase también QInputMethod.

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

Este manejador de eventos, para el evento event, puede ser reimplementado para recibir eventos de rueda para este elemento. Si reimplementas esta función, event será aceptada por defecto.

Si ignoras el evento, (por ejemplo, llamando a QEvent::ignore(),) se propagará a cualquier elemento por debajo de este elemento. Si ningún elemento acepta el evento, será ignorado por la escena, y se propagará a la vista (por ejemplo, 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 este elemento no tiene ventana. Si el elemento es una ventana, se devolverá a sí mismo. Si no, devolverá el ancestro más cercano que sea una ventana.

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

qreal QGraphicsItem::x() const

Esta función es equivalente a llamar a pos().x().

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

qreal QGraphicsItem::y() const

Esta función es equivalente 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 afecta al orden de apilamiento de los elementos hermanos (vecinos).

El valor Z por defecto es 0.

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