En esta página

QQuickItem Class

La clase QQuickItem proporciona el más básico de todos los elementos visuales en Qt Quick. Más...

Cabecera: #include <QQuickItem>
CMake: find_package(Qt6 REQUIRED COMPONENTS Quick)
target_link_libraries(mytarget PRIVATE Qt6::Quick)
qmake: QT += quick
En QML: Item
Hereda: QObject y QQmlParserStatus
Heredado de:

QQuickFramebufferObject, QQuickPaintedItem, y QQuickRhiItem

Tipos públicos

union ItemChangeData
enum Flag { ItemClipsChildrenToShape, ItemAcceptsInputMethod, ItemIsFocusScope, ItemHasContents, ItemAcceptsDrops, …, ItemObservesViewport }
flags Flags
enum ItemChange { ItemChildAddedChange, ItemChildRemovedChange, ItemSceneChange, ItemVisibleHasChanged, ItemParentHasChanged, …, ItemTransformHasChanged }
enum TransformOrigin { TopLeft, Top, TopRight, Left, Center, …, BottomRight }

Propiedades

Funciones públicas

QQuickItem(QQuickItem *parent = nullptr)
virtual ~QQuickItem() override
bool acceptHoverEvents() const
bool acceptTouchEvents() const
Qt::MouseButtons acceptedMouseButtons() const
bool activeFocusOnTab() const
bool antialiasing() const
qreal baselineOffset() const
QBindable<qreal> bindableHeight()
QBindable<qreal> bindableWidth()
QBindable<qreal> bindableX()
QBindable<qreal> bindableY()
virtual QRectF boundingRect() const
QQuickItem *childAt(qreal x, qreal y) const
QList<QQuickItem *> childItems() const
QRectF childrenRect()
bool clip() const
virtual QRectF clipRect() const
QObject *containmentMask() const
virtual bool contains(const QPointF &point) const
QCursor cursor() const
(since 6.3) void dumpItemTree() const
(since 6.3) void ensurePolished()
bool filtersChildMouseEvents() const
QQuickItem::Flags flags() const
Qt::FocusPolicy focusPolicy() const
void forceActiveFocus()
void forceActiveFocus(Qt::FocusReason reason)
QSharedPointer<QQuickItemGrabResult> grabToImage(const QSize &targetSize = QSize())
bool hasActiveFocus() const
bool hasFocus() const
qreal height() const
qreal implicitHeight() const
qreal implicitWidth() const
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const
bool isAncestorOf(const QQuickItem *child) const
bool isEnabled() const
bool isFocusScope() const
virtual bool isTextureProvider() const
bool isVisible() const
bool keepMouseGrab() const
bool keepTouchGrab() const
QPointF mapFromGlobal(const QPointF &point) const
QPointF mapFromItem(const QQuickItem *item, const QPointF &point) const
QPointF mapFromScene(const QPointF &point) const
QRectF mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
QRectF mapRectFromScene(const QRectF &rect) const
QRectF mapRectToItem(const QQuickItem *item, const QRectF &rect) const
QRectF mapRectToScene(const QRectF &rect) const
QPointF mapToGlobal(const QPointF &point) const
QPointF mapToItem(const QQuickItem *item, const QPointF &point) const
QPointF mapToScene(const QPointF &point) const
QQuickItem *nextItemInFocusChain(bool forward = true)
qreal opacity() const
QQuickItem *parentItem() const
void polish()
void resetAntialiasing()
void resetHeight()
void resetWidth()
qreal rotation() const
qreal scale() const
QQuickItem *scopedFocusItem() const
void setAcceptHoverEvents(bool enabled)
void setAcceptTouchEvents(bool enabled)
void setAcceptedMouseButtons(Qt::MouseButtons buttons)
void setActiveFocusOnTab(bool)
void setAntialiasing(bool)
void setBaselineOffset(qreal)
void setClip(bool)
void setContainmentMask(QObject *mask)
void setCursor(const QCursor &cursor)
void setEnabled(bool)
void setFiltersChildMouseEvents(bool filter)
void setFlag(QQuickItem::Flag flag, bool enabled = true)
void setFlags(QQuickItem::Flags flags)
void setFocus(bool)
void setFocus(bool focus, Qt::FocusReason reason)
void setFocusPolicy(Qt::FocusPolicy policy)
void setHeight(qreal)
void setImplicitHeight(qreal)
void setImplicitWidth(qreal)
void setKeepMouseGrab(bool keep)
void setKeepTouchGrab(bool keep)
void setOpacity(qreal)
void setParentItem(QQuickItem *parent)
void setRotation(qreal)
void setScale(qreal)
void setSize(const QSizeF &size)
void setSmooth(bool)
void setState(const QString &)
void setTransformOrigin(QQuickItem::TransformOrigin)
void setVisible(bool)
void setWidth(qreal)
void setX(qreal)
void setY(qreal)
void setZ(qreal)
QSizeF size() const
bool smooth() const
void stackAfter(const QQuickItem *sibling)
void stackBefore(const QQuickItem *sibling)
QString state() const
virtual QSGTextureProvider *textureProvider() const
QQuickItem::TransformOrigin transformOrigin() const
void unsetCursor()
QQuickItem *viewportItem() const
qreal width() const
QQuickWindow *window() const
qreal x() const
qreal y() const
qreal z() const

Ranuras públicas

void update()

Señales

void activeFocusChanged(bool)
void activeFocusOnTabChanged(bool)
void antialiasingChanged(bool)
void baselineOffsetChanged(qreal)
void childrenRectChanged(const QRectF &)
void clipChanged(bool)
void containmentMaskChanged()
void enabledChanged()
void focusChanged(bool)
void focusPolicyChanged(Qt::FocusPolicy)
void heightChanged()
void implicitHeightChanged()
void implicitWidthChanged()
void opacityChanged()
void parentChanged(QQuickItem *)
void rotationChanged()
void scaleChanged()
void smoothChanged(bool)
void stateChanged(const QString &)
void transformOriginChanged(QQuickItem::TransformOrigin)
void visibleChanged()
void widthChanged()
void windowChanged(QQuickWindow *window)
void xChanged()
void yChanged()
void zChanged()

Funciones protegidas

bool virtual childMouseEventFilter(QQuickItem *item, QEvent *event)
virtual void dragEnterEvent(QDragEnterEvent *event)
virtual void dragLeaveEvent(QDragLeaveEvent *event)
virtual void dragMoveEvent(QDragMoveEvent *event)
virtual void dropEvent(QDropEvent *event)
virtual void focusInEvent(QFocusEvent *event)
virtual void focusOutEvent(QFocusEvent *event)
(since 6.0) virtual void geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
bool heightValid() const
void virtual hoverEnterEvent(QHoverEvent *event)
virtual void hoverLeaveEvent(QHoverEvent *event)
virtual void hoverMoveEvent(QHoverEvent *event)
virtual void inputMethodEvent(QInputMethodEvent *event)
bool isComponentComplete() const
virtual void itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
virtual void keyPressEvent(QKeyEvent *event)
virtual void keyReleaseEvent(QKeyEvent *event)
virtual void mouseDoubleClickEvent(QMouseEvent *event)
virtual void mouseMoveEvent(QMouseEvent *event)
virtual void mousePressEvent(QMouseEvent *event)
virtual void mouseReleaseEvent(QMouseEvent *event)
virtual void mouseUngrabEvent()
virtual void releaseResources()
virtual void touchEvent(QTouchEvent *event)
virtual void touchUngrabEvent()
void updateInputMethod(Qt::InputMethodQueries queries = Qt::ImQueryInput)
virtual QSGNode *updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *updatePaintNodeData)
virtual void updatePolish()
virtual void wheelEvent(QWheelEvent *event)
bool widthValid() const

Funciones protegidas reimplementadas

virtual void classBegin() override
virtual void componentComplete() override
virtual bool event(QEvent *ev) override

Descripción Detallada

Todos los elementos visuales de Qt Quick heredan de QQuickItem. Aunque una instancia de QQuickItem no tiene apariencia visual, define todos los atributos que son comunes a los ítems visuales, como la posición x e y, anchura y altura, anclaje y soporte de manejo de teclas.

Puede subclasificar QQuickItem para proporcionar su propio elemento visual personalizado que herede estas características.

Elementos gráficos de escena personalizados

Todos los elementos visuales QML se renderizan utilizando el gráfico de escena, cuya implementación predeterminada es una pila de renderizado de alto rendimiento y bajo nivel, estrechamente vinculada a API de gráficos acelerados, como OpenGL, Vulkan, Metal o Direct 3D. Es posible para las subclases de QQuickItem añadir su propio contenido personalizado en el gráfico de escena estableciendo la bandera QQuickItem::ItemHasContents y reimplementando la función QQuickItem::updatePaintNode().

Advertencia: Es crucial que las operaciones gráficas y la interacción con el gráfico de escena ocurran exclusivamente en el hilo de renderizado, principalmente durante la llamada a updatePaintNode(). La mejor regla general es utilizar únicamente clases con el prefijo "QSG" dentro de la función QQuickItem::updatePaintNode().

Nota: Todas las clases con el prefijo QSG deben utilizarse únicamente en el subproceso de renderizado del gráfico de escena. Ver Gráfico de Escena y Renderizado para más información.

Gestión de recursos gráficos

La forma preferida de manejar la limpieza de los recursos gráficos utilizados en el gráfico de escena, es confiar en la limpieza automática de los nodos. Un QSGNode devuelto desde QQuickItem::updatePaintNode() se borra automáticamente en el hilo adecuado en el momento adecuado. Los árboles de instancias QSGNode se gestionan mediante el uso de QSGNode::OwnedByParent, que se establece por defecto. Por lo tanto, para la mayoría de los elementos gráficos de escena personalizados, no será necesario ningún trabajo adicional.

Las implementaciones que almacenan recursos gráficos fuera del árbol de nodos, como un elemento que implemente QQuickItem::textureProvider(), tendrán que tener cuidado a la hora de limpiarlo correctamente dependiendo de cómo se utilice el elemento en QML. Las situaciones a manejar son:

  • El gráfico de escena se invalida; Esto puede ocurrir, dependiendo de la plataforma y de la configuración de QQuickWindow, cuando la ventana se oculta usando QQuickWindow::hide(), o cuando se cierra. Si la clase item implementa un slot llamado invalidateSceneGraph(), este slot será llamado en el hilo de renderizado mientras el hilo GUI está bloqueado. Esto es equivalente a conectarse a QQuickWindow::sceneGraphInvalidated(). Cuando se renderiza a través de OpenGL, el contexto OpenGL de la ventana de este elemento se vinculará cuando se llame a esta ranura. La única excepción es si el OpenGL nativo ha sido destruido fuera del control de Qt, por ejemplo a través de EGL_CONTEXT_LOST.
  • El ítem es removido de la escena; Si un ítem es removido de la escena, por ejemplo porque su padre fue puesto en null o un ítem en otra ventana, el QQuickItem::releaseResources() será llamado en el hilo GUI. QQuickWindow::scheduleRenderJob() debe utilizarse para programar la limpieza de los recursos de renderizado.
  • El ítem es borrado; Cuando el destructor de un ítem se ejecuta, debería borrar cualquier recurso gráfico que tenga. Si no se cumple ninguna de las dos condiciones anteriores, el elemento formará parte de una ventana y es posible utilizar QQuickWindow::scheduleRenderJob() para que se limpien. Si una implementación ignora la llamada a QQuickItem::releaseResources(), en muchos casos el elemento ya no tendrá acceso a QQuickWindow y, por tanto, no podrá programar la limpieza.

Al programar la limpieza de los recursos gráficos mediante QQuickWindow::scheduleRenderJob(), se debe utilizar QQuickWindow::BeforeSynchronizingStage o QQuickWindow::AfterSynchronizingStage. La etapa de sincronización es en la que se modifica el gráfico de la escena como resultado de los cambios en el árbol QML. Si la limpieza se programa en cualquier otro momento, es posible que otras partes del gráfico de escena hagan referencia a los objetos recién eliminados, ya que estas partes no se han actualizado.

Nota: Se desaconseja encarecidamente el uso de QObject::deleteLater() para limpiar los recursos gráficos, ya que esto hará que la operación delete se ejecute en un momento arbitrario y se desconoce si habrá un contexto OpenGL vinculado cuando se produzca la eliminación.

Elementos personalizados de QPainter

El QQuickItem proporciona una subclase, QQuickPaintedItem, que permite a los usuarios renderizar contenido utilizando QPainter.

Advertencia: El uso de QQuickPaintedItem utiliza una superficie 2D indirecta para renderizar su contenido, utilizando rasterización por software, por lo que el renderizado es una operación de dos pasos. Primero se rasteriza la superficie y luego se dibuja la superficie. Usar directamente la API de scene graph es siempre significativamente más rápido.

Animaciones de comportamiento

Si tu Item utiliza el tipo Behavior para definir animaciones para cambios de propiedades, deberías utilizar siempre QObject::setProperty(), QQmlProperty(), o QMetaProperty::write() cuando necesites modificar esas propiedades desde C++. Esto garantiza que el motor QML conozca el cambio de propiedad. De lo contrario, el motor no podrá llevar a cabo la animación solicitada. Tenga en cuenta que estas funciones conllevan una ligera penalización de rendimiento. Para obtener más información, consulte Acceso a los miembros de un tipo de objeto QML desde C++.

Véase también QQuickWindow y QQuickPaintedItem.

Documentación de tipos de miembros

enum QQuickItem::Bandera
banderas QQuickItem::Banderas

Este tipo enum se utiliza para especificar varias propiedades de los elementos.

ConstanteValorDescripción
QQuickItem::ItemClipsChildrenToShape0x01Indica que este ítem debe recortar visualmente a sus hijos para que se muestren sólo dentro de los límites de este ítem.
QQuickItem::ItemAcceptsInputMethod0x02Indica que el elemento soporta métodos de entrada de texto.
QQuickItem::ItemIsFocusScope0x04Indica que el elemento es un ámbito de enfoque. Consulte Enfoque de teclado en Qt Quick para obtener más información.
QQuickItem::ItemHasContents0x08Indica que el elemento tiene contenido visual y debe ser representado por el gráfico de escena.
QQuickItem::ItemAcceptsDrops0x10Indica que el elemento acepta eventos de arrastrar y soltar.
QQuickItem::ItemIsViewport0x20Indica que el elemento define una ventana gráfica para sus hijos.
QQuickItem::ItemObservesViewport0x40Indica que el ítem desea conocer los límites de la ventana gráfica cuando algún ancestro tiene activado el indicador ItemIsViewport.

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

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

enum QQuickItem::ItemChange

Se utiliza junto con QQuickItem::itemChange() para notificar al elemento ciertos tipos de cambios.

ConstanteValorDescripción
QQuickItem::ItemChildAddedChange0Se ha añadido un hijo. ItemChangeData::item contiene el hijo añadido.
QQuickItem::ItemChildRemovedChange1Se ha eliminado un hijo. ItemChangeData::item contiene el hijo eliminado.
QQuickItem::ItemSceneChange2El elemento se ha añadido o eliminado de una escena. La representación de la escena en QQuickWindow se especifica en ItemChangeData::window. El parámetro de ventana es nulo cuando el elemento se elimina de una escena.
QQuickItem::ItemVisibleHasChanged3La visibilidad del elemento ha cambiado. ItemChangeData::boolValue contiene la nueva visibilidad.
QQuickItem::ItemParentHasChanged4El padre del elemento ha cambiado. ItemChangeData::item contiene el nuevo padre.
QQuickItem::ItemOpacityHasChanged5La opacidad del elemento ha cambiado. ItemChangeData::realValue contiene la nueva opacidad.
QQuickItem::ItemActiveFocusHasChanged6El foco del elemento ha cambiado. ItemChangeData::boolValue contiene si el elemento tiene foco o no.
QQuickItem::ItemRotationHasChanged7La rotación del elemento ha cambiado. ItemChangeData::realValue contiene la nueva rotación.
QQuickItem::ItemDevicePixelRatioHasChanged9La proporción de píxeles del dispositivo de la pantalla en la que se encuentra el elemento ha cambiado. ItemChangedData::realValue contiene la nueva relación de píxeles del dispositivo.
QQuickItem::ItemAntialiasingHasChanged8El antialiasing ha cambiado. El valor actual (booleano) se encuentra en QQuickItem::antialiasing.
QQuickItem::ItemEnabledHasChanged10El estado activado del elemento ha cambiado. ItemChangeData::boolValue contiene el nuevo estado activado. (desde Qt 5.10)
QQuickItem::ItemScaleHasChanged11La escala del elemento ha cambiado. ItemChangeData::realValue contiene la escala. (desde Qt 6.9)
QQuickItem::ItemTransformHasChanged12La transformación del elemento ha cambiado. Esto ocurre cuando la posición, el tamaño, la rotación, la escala, transformOrigin o las transformaciones adjuntas del elemento cambian. ItemChangeData::item contiene el elemento que causó el cambio. (desde Qt 6.9)

enum QQuickItem::TransformOrigin

Controla el punto sobre el que se aplican transformaciones simples como la escala.

ConstanteValorDescripción
QQuickItem::TopLeft0La esquina superior izquierda del elemento.
QQuickItem::Top1El punto central de la parte superior del ítem.
QQuickItem::TopRight2La esquina superior derecha del elemento.
QQuickItem::Left3El punto más a la izquierda del centro vertical.
QQuickItem::Center4El centro del elemento.
QQuickItem::Right5El punto más a la derecha del centro vertical.
QQuickItem::BottomLeft6La esquina inferior izquierda del elemento.
QQuickItem::Bottom7El punto central de la parte inferior del elemento.
QQuickItem::BottomRight8La esquina inferior derecha del elemento.

Véase también transformOrigin() y setTransformOrigin().

Documentación de propiedades

[read-only] activeFocus : bool

Esta propiedad de sólo lectura indica si el elemento tiene el foco activo.

Si activeFocus es verdadero, este elemento es el que actualmente recibe la entrada del teclado, o es un FocusScope ancestro del elemento que actualmente recibe la entrada del teclado.

Normalmente, activeFocus se obtiene estableciendo focus en un elemento y en los objetos FocusScope que lo rodean. En el siguiente ejemplo, los objetos input y focusScope tendrán el foco activo, mientras que el objeto rectángulo raíz no lo tendrá.

import QtQuick 2.0

Rectangle {
    width: 100; height: 100

    FocusScope {
        focus: true

        TextInput {
            id: input
            focus: true
        }
    }
}

Funciones de acceso:

bool hasActiveFocus() const

Señal del notificador:

void activeFocusChanged(bool)

Véase también focus y Enfoque del teclado en Qt Quick.

activeFocusOnTab : bool

Esta propiedad indica si el elemento quiere estar en la cadena de enfoque de la pestaña. Por defecto, se establece en false.

Nota: tabFocusBehavior puede limitar aún más el foco a sólo tipos específicos de controles, como sólo controles de texto o de lista. Este es el caso de macOS, donde el foco de determinados controles puede estar restringido en función de la configuración del sistema.

Funciones de acceso:

bool activeFocusOnTab() const
void setActiveFocusOnTab(bool)

Señal del notificador:

void activeFocusOnTabChanged(bool)

Véase también QStyleHints::tabFocusBehavior y focusPolicy.

antialiasing : bool

Especifica si el elemento tiene antialiasing o no.

Utilizado por los elementos visuales para decidir si el elemento debe utilizar antialiasing o no. En algunos casos los elementos con antialiasing requieren más memoria y son potencialmente más lentos de renderizar (ver Antialiasing para más detalles).

Por defecto es false, pero puede ser sobreescrito por elementos derivados.

Funciones de acceso:

bool antialiasing() const
void setAntialiasing(bool)
void resetAntialiasing()

Señal de notificador:

void antialiasingChanged(bool)

baselineOffset : qreal

Especifica la posición de la línea de base del elemento en coordenadas locales.

La línea de base de un elemento Text es la línea imaginaria sobre la que se sitúa el texto. Los controles que contienen texto suelen fijar su línea de base en la línea de base de su texto.

Para los elementos que no contienen texto, se utiliza una línea de base por defecto de 0.

Funciones de acceso:

qreal baselineOffset() const
void setBaselineOffset(qreal)

Señal del notificador:

void baselineOffsetChanged(qreal)

[read-only] childrenRect : QRectF

Esta propiedad contiene la posición colectiva y el tamaño de los elementos hijos.

Esta propiedad es útil si necesitas acceder a la geometría colectiva de los hijos de un elemento para dimensionar correctamente el elemento.

La geometría que se devuelve es local al elemento. Por ejemplo:

Item {
    x: 50
    y: 100

    // prints: QRectF(-10, -20, 30, 40)
    Component.onCompleted: print(childrenRect)

    Item {
        x: -10
        y: -20
        width: 30
        height: 40
    }
}

Funciones de acceso:

QRectF childrenRect()

Señal del notificador:

void childrenRectChanged(const QRectF &)

clip : bool

Esta propiedad indica si el recorte está activado. El valor de recorte por defecto es false.

Si el recorte está habilitado, un elemento recortará su propia pintura, así como la pintura de sus hijos, a su rectángulo delimitador. Si activas el recorte durante la operación de pintado de un elemento, recuerda volver a activarlo para evitar que se recorte el resto de la escena.

Nota: El recorte puede afectar al rendimiento del renderizado. Consulte Recorte para obtener más información.

Nota: Por el bien de QML, establecer clip a true también establece la bandera ItemIsViewport, que a veces actúa como una optimización: los elementos hijos que tienen la bandera ItemObservesViewport pueden renunciar a crear nodos del gráfico de escena que caen fuera de la ventana gráfica. Sin embargo, el indicador ItemIsViewport también puede establecerse de forma independiente.

Funciones de acceso:

bool clip() const
void setClip(bool)

Señal de notificación:

void clipChanged(bool)

containmentMask : QObject*

Esta propiedad contiene una máscara opcional que se utilizará en el método contains(), que se utiliza principalmente para probar cada QPointerEvent.

Por defecto, contains() devolverá true para cualquier punto dentro del cuadro delimitador del elemento. Pero cualquier QQuickItem, o cualquier QObject que implemente una función de la forma

Q_INVOKABLE bool contains(const QPointF &point) const;

puede utilizarse como máscara, para diferir la prueba de acierto a ese objeto.

Nota: contains() se llama frecuentemente durante la entrega de eventos. Diferir la prueba de impacto a otro objeto la ralentiza un poco. containmentMask() puede causar problemas de rendimiento si el método contains() de ese objeto no es eficiente. Si implementas una subclase personalizada de QQuickItem, puedes alternativamente anular contains().

Funciones de acceso:

QObject *containmentMask() const
void setContainmentMask(QObject *mask)

Señal de notificador:

void containmentMaskChanged()

Véase también contains().

enabled : bool

Esta propiedad indica si el elemento recibe eventos de ratón y teclado. Por defecto es true.

Establecer esta propiedad afecta directamente al valor enabled de los ítems hijos. Cuando se establece a false, los valores de enabled de todos los ítems hijos también se convierten en false. Cuando se establece a true, los valores enabled de los ítems hijos vuelven a true, a menos que hayan sido explícitamente establecidos a false.

Si se establece esta propiedad en false, activeFocus se convierte automáticamente en false, y este elemento dejará de recibir eventos de teclado.

Nota: Los eventos Hover se activan por separado mediante setAcceptHoverEvents(). Así, un elemento deshabilitado puede seguir recibiendo eventos hover, incluso cuando esta propiedad es false. Esto hace posible mostrar información (como ToolTip) incluso cuando un elemento interactivo está deshabilitado. Lo mismo ocurre con cualquier HoverHandlers añadido como hijo del elemento. Un HoverHandler puede, sin embargo, ser disabled explícitamente, o por ejemplo estar ligado al estado enabled del elemento.

Funciones de acceso:

bool isEnabled() const
void setEnabled(bool)

Señal de notificación:

void enabledChanged()

Véase también visible.

focus : bool

Esta propiedad indica si el elemento tiene foco dentro del elemento adyacente FocusScope. Si es verdadero, este elemento obtendrá el foco activo cuando el elemento FocusScope adquiera el foco activo.

En el siguiente ejemplo, input tendrá foco activo cuando scope tenga foco activo:

import QtQuick 2.0

Rectangle {
    width: 100; height: 100

    FocusScope {
        id: scope

        TextInput {
            id: input
            focus: true
        }
    }
}

A efectos de esta propiedad, se supone que la escena en su conjunto actúa como un ámbito de foco. A nivel práctico, esto significa que el siguiente QML dará foco activo a input al iniciarse.

Rectangle {
    width: 100; height: 100

    TextInput {
          id: input
          focus: true
    }
}

Funciones de acceso:

bool hasFocus() const
void setFocus(bool)
void setFocus(bool focus, Qt::FocusReason reason)

Señal de notificador:

void focusChanged(bool)

Véase también activeFocus y Keyboard Focus en Qt Quick.

[since 6.7] focusPolicy : Qt::FocusPolicy

Esta propiedad determina la forma en que el elemento acepta el foco.

Esta propiedad se introdujo en Qt 6.7.

Funciones de acceso:

Qt::FocusPolicy focusPolicy() const
void setFocusPolicy(Qt::FocusPolicy policy)

Señal del notificador:

void focusPolicyChanged(Qt::FocusPolicy)

[bindable] height : qreal

Nota: Esta propiedad es compatible con QProperty.

Esta propiedad contiene la altura de este elemento.

Funciones de acceso:

qreal height() const
void setHeight(qreal)
void resetHeight()

Señal del notificador:

void heightChanged()

implicitHeight : qreal

implicitWidth : qreal

Define la anchura o altura preferida del elemento.

Si no se especifica width o height, el tamaño efectivo de un elemento vendrá determinado por su implicitWidth o implicitHeight.

Sin embargo, si un elemento es hijo de un diseño, el diseño determinará el tamaño preferido del elemento utilizando su tamaño implícito. En este caso, se ignorará el tamaño explícito de width o height.

El tamaño implícito por defecto para la mayoría de los elementos es 0x0, sin embargo algunos elementos tienen un tamaño implícito inherente que no puede ser anulado, por ejemplo, Image y Text.

Establecer el tamaño implícito es útil para definir componentes que tienen un tamaño preferido basado en su contenido, por ejemplo:

// Label.qml
import QtQuick 2.0

Item {
    property alias icon: image.source
    property alias label: text.text
    implicitWidth: text.implicitWidth + image.implicitWidth
    implicitHeight: Math.max(text.implicitHeight, image.implicitHeight)
    Image { id: image }
    Text {
        id: text
        wrapMode: Text.Wrap
        anchors.left: image.right; anchors.right: parent.right
        anchors.verticalCenter: parent.verticalCenter
    }
}

Nota: Si se utiliza implicitWidth de Text o TextEdit y se define explícitamente la anchura, el rendimiento se verá afectado, ya que el texto deberá presentarse dos veces.

opacity : qreal

Esta propiedad contiene la opacidad del elemento. La opacidad se especifica como un número entre 0.0 (totalmente transparente) y 1.0 (totalmente opaco). El valor por defecto es 1.0.

Cuando se establece esta propiedad, la opacidad especificada también se aplica individualmente a los elementos hijos. Esto puede tener un efecto no deseado en algunas circunstancias. Por ejemplo, en el segundo conjunto de rectángulos de abajo, el rectángulo rojo ha especificado una opacidad de 0,5, que afecta a la opacidad de su rectángulo azul hijo, aunque el hijo no haya especificado una opacidad.

Los valores fuera del rango de 0 a 1 serán fijados.

Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Item {
    Rectangle {
        opacity: 0.5
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Cambiar la opacidad de un elemento no afecta a si el elemento recibe eventos de entrada del usuario. (Por el contrario, establecer la propiedad visible a false detiene los eventos de ratón, y establecer la propiedad enabled a false detiene los eventos de ratón y teclado, y también elimina el foco activo del elemento).

Funciones de acceso:

qreal opacity() const
void setOpacity(qreal)

Señal de notificador:

void opacityChanged()

Véase también visible.

parent : QQuickItem*

Esta propiedad contiene el padre visual del elemento.

Nota: El concepto de padre visual difiere del de padreQObject . El padre visual de un ítem puede no ser necesariamente el mismo que su objeto padre. Ver Conceptos - Padre visual en Qt Quick para más detalles.

Nota: La señal de notificación para esta propiedad se emite durante la destrucción del padre visual. Los manejadores de señales C++ no pueden asumir que los elementos en la jerarquía visual padre están todavía completamente construidos. Utilice qobject_cast para verificar que los elementos de la jerarquía padre pueden utilizarse de forma segura como el tipo esperado.

Funciones de acceso:

QQuickItem *parentItem() const
void setParentItem(QQuickItem *parent)

Señal de notificador:

void parentChanged(QQuickItem *)

rotation : qreal

Esta propiedad contiene la rotación del elemento en grados en el sentido de las agujas del reloj alrededor de su transformOrigin.

El valor por defecto es 0 grados (es decir, sin rotación).

Rectangle {
    color: "blue"
    width: 100; height: 100
    Rectangle {
        color: "red"
        x: 25; y: 25; width: 50; height: 50
        rotation: 30
    }
}

Funciones de acceso:

qreal rotation() const
void setRotation(qreal)

Señal del notificador:

void rotationChanged()

Véase también Transform y Rotation.

scale : qreal

Esta propiedad contiene el factor de escala para este elemento.

Una escala inferior a 1,0 hace que el elemento se muestre a un tamaño menor, y una escala superior a 1,0 hace que el elemento se muestre a un tamaño mayor. Una escala negativa hace que el elemento se refleje al renderizarlo.

El valor por defecto es 1.0.

La escala se aplica desde transformOrigin.

import QtQuick 2.0

Rectangle {
    color: "blue"
    width: 100; height: 100

    Rectangle {
        color: "green"
        width: 25; height: 25
    }

    Rectangle {
        color: "red"
        x: 25; y: 25; width: 50; height: 50
        scale: 1.4
    }
}

Funciones de acceso:

qreal scale() const
void setScale(qreal)

Señal notificadora:

void scaleChanged()

Véase también Transform y Scale.

smooth : bool

Especifica si el elemento está suavizado o no.

Se utiliza principalmente en elementos basados en imágenes para decidir si el elemento debe utilizar un muestreo suave o no. El muestreo suavizado se realiza mediante interpolación lineal, mientras que el no suavizado se realiza mediante el vecino más próximo.

En Qt Quick 2.0, esta propiedad tiene un impacto mínimo en el rendimiento.

Por defecto, esta propiedad se establece en true.

Funciones de acceso:

bool smooth() const
void setSmooth(bool)

Señal del notificador:

void smoothChanged(bool)

state : QString

Esta propiedad contiene el nombre del estado actual del elemento.

Si el elemento está en su estado por defecto, es decir, no se ha establecido ningún estado explícito, esta propiedad contendrá una cadena vacía. Del mismo modo, puede devolver un elemento a su estado por defecto estableciendo esta propiedad a una cadena vacía.

Funciones de acceso:

QString state() const
void setState(const QString &)

Señal del notificador:

void stateChanged(const QString &)

Véase también Qt Quick Estados.

transformOrigin : TransformOrigin

Esta propiedad contiene el punto de origen alrededor del cual se transforman la escala y la rotación.

Hay nueve orígenes de transformación disponibles, como se muestra en la siguiente imagen. El origen de transformación por defecto es Item.Center.

Funciones de acceso:

QQuickItem::TransformOrigin transformOrigin() const
void setTransformOrigin(QQuickItem::TransformOrigin)

Señal de notificador:

void transformOriginChanged(QQuickItem::TransformOrigin)

visible : bool

Esta propiedad indica si el elemento es visible. Por defecto es true.

Establecer esta propiedad afecta directamente al valor visible de los elementos hijos. Cuando se establece a false, los valores de visible de todos los elementos hijos también se convierten en false. Cuando se establece a true, los valores de visible de los elementos hijos vuelven a true, a menos que se hayan establecido explícitamente a false.

(Debido a este comportamiento, el uso de la propiedad visible puede no tener el efecto deseado si un enlace de propiedad sólo debe responder a cambios explícitos de propiedad. En tales casos, puede ser mejor utilizar la propiedad opacity en su lugar).

Si esta propiedad se establece en false, el elemento dejará de recibir eventos de ratón, pero seguirá recibiendo eventos de teclado y conservará el teclado focus si se ha establecido. (Por el contrario, establecer la propiedad enabled a false detiene tanto los eventos de ratón como de teclado, y también elimina el foco del elemento).

Nota: El valor de esta propiedad sólo se ve afectado por cambios en esta propiedad o en la propiedad visible del elemento padre. No cambia, por ejemplo, si este ítem se mueve fuera de la pantalla, o si el opacity cambia a 0. Sin embargo, por razones históricas, esta propiedad es verdadera después de la construcción del ítem, incluso si el ítem no ha sido añadido a una escena todavía. Cambiar o leer esta propiedad de un ítem que no ha sido añadido a una escena podría no producir los resultados esperados.

Nota: La señal de notificación de esta propiedad se emite durante la destrucción del elemento visual padre. Los manejadores de señales C++ no pueden asumir que los elementos en la jerarquía visual padre están todavía completamente construidos. Utilice qobject_cast para verificar que los elementos de la jerarquía padre pueden utilizarse de forma segura como el tipo esperado.

Funciones de acceso:

bool isVisible() const
void setVisible(bool)

Señal de notificador:

void visibleChanged()

Véase también opacity y enabled.

[bindable] width : qreal

Nota: Esta propiedad es compatible con QProperty.

Esta propiedad contiene el ancho de este elemento.

Funciones de acceso:

qreal width() const
void setWidth(qreal)
void resetWidth()

Señal del notificador:

void widthChanged()

[bindable] x : qreal

Nota: Esta propiedad es compatible con QProperty.

Define la posición x del elemento respecto a su padre.

Funciones de acceso:

qreal x() const
void setX(qreal)

Señal del notificador:

void xChanged()

[bindable] y : qreal

Nota: Esta propiedad es compatible con QProperty.

Define la posición y del elemento respecto a su padre.

Funciones de acceso:

qreal y() const
void setY(qreal)

Señal del notificador:

void yChanged()

z : qreal

Establece el orden de apilamiento de los elementos hermanos. Por defecto, el orden de apilamiento es 0.

Los elementos con un valor de apilamiento mayor se dibujan encima de sus hermanos con un orden de apilamiento menor. Los elementos con el mismo valor de apilamiento se dibujan de abajo hacia arriba en el orden en que aparecen. Los elementos con un valor de apilamiento negativo se dibujan debajo del contenido de su padre.

El siguiente ejemplo muestra los distintos efectos del orden de apilamiento.

Mismo z - los elementos posteriores están por encima de los anteriores:
Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

Más arriba z:
Item {
    Rectangle {
        z: 1
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

Mismo z - hijos por encima de padres:
Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Más bajo z abajo:
Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            z: -1
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Funciones de acceso:

qreal z() const
void setZ(qreal)

Señal de aviso:

void zChanged()

Documentación de funciones miembro

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

Construye un QQuickItem con la dirección parent.

parent se utilizará como padre de visual parent y de QObject.

[override virtual noexcept] QQuickItem::~QQuickItem()

Destruye el QQuickItem.

bool QQuickItem::acceptHoverEvents() const

Devuelve si los eventos hover son aceptados por este elemento.

El valor por defecto es false.

Si es false, el elemento no recibirá eventos hover a través de las funciones hoverEnterEvent(), hoverMoveEvent() y hoverLeaveEvent().

Véase también setAcceptHoverEvents().

bool QQuickItem::acceptTouchEvents() const

Devuelve si los eventos táctiles son aceptados por este elemento.

El valor por defecto es false.

Si es false, entonces el elemento no recibirá ningún evento táctil a través de la función touchEvent().

Véase también setAcceptTouchEvents().

Qt::MouseButtons QQuickItem::acceptedMouseButtons() const

Devuelve los botones del ratón aceptados por este elemento.

El valor por defecto es Qt::NoButton; es decir, no se acepta ningún botón del ratón.

Si un elemento no acepta el botón del ratón para un evento del ratón en particular, el evento del ratón no será entregado al elemento y será entregado al siguiente elemento en la jerarquía de elementos en su lugar.

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

[virtual] QRectF QQuickItem::boundingRect() const

Devuelve las extensiones del elemento en su propio sistema de coordenadas: un rectángulo desde 0, 0 hasta width() y height().

[invokable] QQuickItem *QQuickItem::childAt(qreal x, qreal y) const

Devuelve el primer elemento hijo visible encontrado en el punto (x, y) dentro del sistema de coordenadas de este elemento.

Devuelve nullptr si no existe tal elemento.

Nota: Esta función puede invocarse a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.

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

Devuelve los hijos de este elemento.

[virtual protected] bool QQuickItem::childMouseEventFilter(QQuickItem *item, QEvent *event)

Reimplemente este método para filtrar los eventos de puntero que reciben los hijos de este elemento.

Este método sólo será llamado si filtersChildMouseEvents() es true.

Devuelve true si el event especificado no debe pasarse al item hijo especificado , y false en caso contrario. Si devuelve true, también debe accept o ignore el event, para señalar si la propagación de eventos debe detenerse o continuar. El event, sin embargo, siempre será enviado a todos los childMouseEventFilters de la cadena padre.

Nota: A pesar del nombre, esta función filtra todas las instancias de QPointerEvent durante el envío a todos los hijos (típicamente eventos de ratón, táctiles y de tableta). Cuando sobrescriba esta función en una subclase, le sugerimos que escriba código genérico de gestión de eventos utilizando únicamente los accesores que se encuentran en QPointerEvent. Alternativamente puedes activar event->type() y/o event->device()->type() para manejar diferentes tipos de eventos de diferentes maneras.

Nota: El filtrado es sólo una forma de compartir la responsabilidad en caso de ambigüedad gestual (por ejemplo, al pulsar, no sabes si el usuario va a tocar o arrastrar). Otra forma es llamar a QPointerEvent::addPassiveGrabber() al pulsar, para monitorizar de forma no exclusiva el progreso de QEventPoint. En cualquier caso, el manejador del elemento o puntero que está monitorizando puede robar el agarre exclusivo más tarde, cuando quede claro que el gesto se ajusta al patrón que está esperando.

Véase también setFiltersChildMouseEvents().

[override virtual protected] void QQuickItem::classBegin()

Reimplementa: QQmlParserStatus::classBegin().

Las clases derivadas deben llamar al método de la clase base antes de añadir su propia acción a realizar en classBegin.

[virtual] QRectF QQuickItem::clipRect() const

Devuelve el área rectangular dentro de este elemento que es visible actualmente en viewportItem(), si hay un viewport y la bandera ItemObservesViewport está activada; en caso contrario, las extensiones de este elemento en su propio sistema de coordenadas: un rectángulo desde 0, 0 hasta width() y height(). Esta es la región que debe permanecer visible si clip es true. También puede utilizarse en updatePaintNode() para limitar los gráficos añadidos al gráfico de la escena.

Por ejemplo, un dibujo grande o un documento de texto grande puede mostrarse en un Flickable que ocupe sólo parte de la ventana de la aplicación: en ese caso, Flickable es el elemento viewport, y un elemento de renderizado de contenido personalizado puede optar por omitir los nodos del gráfico de escena que queden fuera del área visible en ese momento. Si se activa el indicador ItemObservesViewport, esta área cambiará cada vez que el usuario desplace el contenido del elemento Flickable.

En el caso de elementos de vista anidados, clipRect() es la intersección de los boundingRects de todos los ancestros que tengan la bandera ItemIsViewport activada, mapeada al sistema de coordenadas de este elemento.

Véase también boundingRect().

[override virtual protected] void QQuickItem::componentComplete()

Reimplementa: QQmlParserStatus::componentComplete().

Las clases derivadas deben llamar al método de la clase base antes de añadir sus propias acciones a realizar en componentComplete.

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

Devuelve true si este elemento contiene point, que está en coordenadas locales; devuelve false en caso contrario.

Esta función puede sobreescribirse para manejar colisiones de puntos en elementos con formas personalizadas. La implementación por defecto comprueba si el punto está dentro de containmentMask() si está establecido, o dentro de la caja delimitadora en caso contrario.

Nota: Este método se utiliza para comprobar cada QEventPoint durante la entrega del evento, por lo que la implementación debe ser lo más ligera posible.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

QCursor QQuickItem::cursor() const

Devuelve la forma del cursor para este elemento.

El cursor del ratón asumirá esta forma cuando esté sobre este elemento, a menos que se establezca un cursor de anulación. Véase list of predefined cursor objects para una gama de formas útiles.

Si no se ha establecido ninguna forma de cursor, devuelve un cursor con la forma Qt::ArrowCursor, aunque puede mostrarse otra forma de cursor si un elemento superpuesto tiene un cursor válido.

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

[virtual protected] void QQuickItem::dragEnterEvent(QDragEnterEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastrar-entrar para un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

Véase también Drag y Arrastrar y soltar.

[virtual protected] void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastre-abandono de un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

Véase también Drag y Arrastrar y soltar.

[virtual protected] void QQuickItem::dragMoveEvent(QDragMoveEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastrar-mover para un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

Véase también Drag y Arrastrar y soltar.

[virtual protected] void QQuickItem::dropEvent(QDropEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de caída de un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

Véase también Drag y Arrastrar y soltar.

[invokable, since 6.3] void QQuickItem::dumpItemTree() const

Vuelca algunos detalles sobre el árbol visual de los ítems que comienzan con este ítem, recursivamente.

Nota: QObject::dumpObjectTree() vuelca un árbol similar; pero, como se explica en Conceptos - Visual Parent en Qt Quick, QObject::parent() de un elemento a veces difiere de su QQuickItem::parentItem(). Puede volcar ambos árboles para ver la diferencia.

Nota: El formato exacto de salida puede cambiar en futuras versiones de Qt.

Nota: Esta función puede ser invocada a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.

Esta función se introdujo en Qt 6.3.

Véase también Técnicas de depuración y GammaRay's Qt Quick Inspector.

[invokable, since 6.3] void QQuickItem::ensurePolished()

Llama a updatePolish()

Esto puede ser útil para elementos como Layouts (o Posicionadores) que retrasan el cálculo de sus implicitWidth y implicitHeight hasta que reciben un PolishEvent.

Normalmente, si, por ejemplo, se añade o elimina un elemento hijo a un Layout, el tamaño implícito no se calcula inmediatamente (esto es una optimización). En algunos casos puede ser deseable consultar el tamaño implícito del layout justo después de añadir un elemento hijo. Si este es el caso, utilice esta función justo antes de consultar el tamaño implícito.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Esta función se introdujo en Qt 6.3.

Véase también updatePolish() y polish().

[override virtual protected] bool QQuickItem::event(QEvent *ev)

Reimplementa: QObject::event(QEvent *e).

bool QQuickItem::filtersChildMouseEvents() const

Devuelve si los eventos de puntero destinados a los elementos hijos de este elemento deben filtrarse a través de este elemento.

Si tanto este elemento como un elemento hijo tienen acceptTouchEvents() true, cuando se produzca una interacción táctil, este elemento filtrará el evento táctil. Pero si este elemento o el hijo no pueden manejar eventos táctiles, childMouseEventFilter() será llamado con un evento de ratón sintetizado.

Véase también setFiltersChildMouseEvents() y childMouseEventFilter().

QQuickItem::Flags QQuickItem::flags() const

Devuelve las banderas de artículo de este artículo.

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

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

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de enfoque de un ítem. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

Si reimplementa esta función, debe llamar a la implementación de la clase base.

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

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de focus-out para un ítem. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[invokable] void QQuickItem::forceActiveFocus()

Fuerza el enfoque activo en el elemento.

Este método establece el foco en el elemento y asegura que todos los objetos FocusScope ancestros en la jerarquía de objetos también reciban focus.

La razón del cambio de foco será Qt::OtherFocusReason. Utilice el método sobrecargado para especificar la razón del foco para permitir un mejor manejo del cambio de foco.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también activeFocus.

[invokable] void QQuickItem::forceActiveFocus(Qt::FocusReason reason)

Fija el foco activo en el elemento con el valor reason.

Este método establece el foco en el elemento y garantiza que todos los objetos FocusScope antecesores en la jerarquía de objetos también reciban focus.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Se trata de una función sobrecargada.

Véase también activeFocus y Qt::FocusReason.

[virtual protected, since 6.0] void QQuickItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)

Esta función es llamada para manejar los cambios de geometría de este ítem de oldGeometry a newGeometry. Si las dos geometrías son iguales, no hace nada.

Las clases derivadas deben llamar al método de la clase base dentro de su implementación.

Esta función se introdujo en Qt 6.0.

QSharedPointer<QQuickItemGrabResult> QQuickItem::grabToImage(const QSize &targetSize = QSize())

Recoge el elemento en una imagen en memoria.

La captura se produce de forma asíncrona y la señal QQuickItemGrabResult::ready() se emite cuando la captura se ha completado.

Utilice targetSize para especificar el tamaño de la imagen de destino. Por defecto, el resultado tendrá el mismo tamaño que item.

Si no se ha podido iniciar la captura, la función devuelve null.

Nota: Esta función renderizará el elemento en una superficie fuera de la pantalla y copiará esa superficie de la memoria de la GPU a la memoria de la CPU, lo que puede resultar bastante costoso. Para una previsualización "en vivo", utilice layers o ShaderEffectSource.

Véase también QQuickWindow::grabWindow().

[protected] bool QQuickItem::heightValid() const

Devuelve si la propiedad de altura se ha establecido explícitamente.

[virtual protected] void QQuickItem::hoverEnterEvent(QHoverEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-enter de un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.

El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::hoverLeaveEvent(QHoverEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-leave de un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.

El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::hoverMoveEvent(QHoverEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-move de un ítem. La información del evento es proporcionada por el parámetro event.

Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.

El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

qreal QQuickItem::implicitWidth() const

Devuelve la anchura del elemento que está implícita en otras propiedades que determinan el contenido.

Nota: Función Getter para la propiedad implicitWidth.

Véase también setImplicitWidth().

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

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de métodos de entrada para un elemento. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

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

Este método sólo es relevante para los elementos de entrada.

Si este elemento es un elemento de entrada, este método debería reimplementarse para devolver los indicadores de método de entrada relevantes para el query dado.

Véase también QWidget::inputMethodQuery().

bool QQuickItem::isAncestorOf(const QQuickItem *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().

[protected] bool QQuickItem::isComponentComplete() const

Devuelve true si se ha completado la construcción del componente QML; en caso contrario, devuelve false.

A menudo es conveniente retrasar algún proceso hasta que el componente se haya completado.

Véase también componentComplete().

bool QQuickItem::isFocusScope() const

Devuelve true si este elemento es un ámbito de enfoque, y false en caso contrario.

[virtual] bool QQuickItem::isTextureProvider() const

Devuelve true si este elemento es un proveedor de textura. La implementación por defecto devuelve false.

Esta función puede ser llamada desde cualquier hilo.

[virtual protected] void QQuickItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)

Se llama cuando se produce change para este elemento.

value contiene información adicional relativa al cambio, cuando procede.

Si reimplementa este método en una subclase, asegúrese de llamar a

QQuickItem::itemChange(change, value);

típicamente al final de su implementación, para asegurarse de que se emita la señal windowChanged().

bool QQuickItem::keepMouseGrab() const

Devuelve si la entrada del ratón debe permanecer exclusivamente en este elemento.

Véase también setKeepMouseGrab(), QEvent::accept() y QEvent::ignore().

bool QQuickItem::keepTouchGrab() const

Devuelve si los puntos de contacto capturados por este elemento deben permanecer exclusivamente con este elemento.

Véase también setKeepTouchGrab(), keepMouseGrab(), QEvent::accept() y QEvent::ignore().

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

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de pulsación de teclas para un elemento. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

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

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de liberación de teclas para un elemento. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[invokable] QPointF QQuickItem::mapFromGlobal(const QPointF &point) const

Mapea el point dado en el sistema global de coordenadas de la pantalla al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Por ejemplo, esto puede ser útil para añadir una ventana emergente a un componente Qt Quick.

Nota: el posicionamiento de la ventana lo realiza el gestor de ventanas y este valor se trata sólo como una sugerencia. Por lo tanto, la posición resultante de la ventana puede diferir de la esperada.

Nota: Si este elemento está en una subescena, por ejemplo, mapeado en un objeto 3D Model, el mapeado UV se incorpora en esta transformación, de modo que realmente va desde las coordenadas de la pantalla a las coordenadas de este elemento, siempre y cuando point esté realmente dentro de los límites de este elemento. Las otras funciones de mapeado aún no trabajan de esa manera.

Nota: Esta función puede invocarse a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

[invokable] QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const

Asigna el punto point dado en el sistema de coordenadas de item al punto equivalente dentro del sistema de coordenadas de este elemento y devuelve la coordenada asignada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Si item es nullptr, esto mapea point desde el sistema de coordenadas de la escena.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el point dado en el sistema de coordenadas de la escena al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el rect dado en el sistema de coordenadas de item al área rectangular equivalente dentro del sistema de coordenadas de este elemento, y devuelve el valor del rectángulo mapeado.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Si item es nullptr, esto mapea rect desde el sistema de coordenadas de la escena.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el rect dado en el sistema de coordenadas de la escena al área rectangular equivalente dentro del sistema de coordenadas de este elemento, y devuelve el valor del rectángulo mapeado.

Las siguientes propiedades del elemento se utilizan en la asignación: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el rect dado en el sistema de coordenadas de este elemento al área rectangular equivalente dentro del sistema de coordenadas de item y devuelve el valor del rectángulo mapeado.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Si item es nullptr, esto mapea rect al sistema de coordenadas de la escena.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el rect dado en el sistema de coordenadas de este elemento al área rectangular equivalente dentro del sistema de coordenadas de la escena, y devuelve el valor del rectángulo mapeado.

Las siguientes propiedades del elemento se utilizan en la asignación: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

[invokable] QPointF QQuickItem::mapToGlobal(const QPointF &point) const

Mapea el point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema global de coordenadas de la pantalla, y devuelve la coordenada mapeada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Por ejemplo, esto puede ser útil para añadir una ventana emergente a un componente Qt Quick.

Nota: el posicionamiento de la ventana lo realiza el gestor de ventanas y este valor se trata sólo como una sugerencia. Por lo tanto, la posición resultante de la ventana puede diferir de la esperada.

Nota: Esta función puede ser invocada a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

[invokable] QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const

Asigna el punto point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de item y devuelve la coordenada asignada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeo incluye la posición relativa de las dos escenas.

Si item es nullptr, esto mapea point al sistema de coordenadas de la escena.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

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

Mapea el point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de la escena, y devuelve la coordenada mapeada.

Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.

Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.

Véase también Conceptos - Coordenadas visuales en Qt Quick.

[virtual protected] void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de doble clic del ratón para un elemento. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::mouseMoveEvent(QMouseEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de movimiento del ratón para un ítem. La información del evento es proporcionada por el parámetro event.

Para recibir eventos de movimiento del ratón, el evento de pulsación del ratón precedente debe ser aceptado (anulando mousePressEvent(), por ejemplo) y acceptedMouseButtons() debe devolver el botón del ratón correspondiente.

El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si se reimplementa esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::mousePressEvent(QMouseEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de pulsación del ratón para un elemento. La información del evento es proporcionada por el parámetro event.

Para recibir eventos de pulsación del ratón, acceptedMouseButtons() debe devolver el botón del ratón correspondiente.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::mouseReleaseEvent(QMouseEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de liberación del ratón para un ítem. La información del evento es proporcionada por el parámetro event.

Para recibir eventos de liberación del ratón, el evento precedente de pulsación del ratón debe ser aceptado (anulando mousePressEvent(), por ejemplo) y acceptedMouseButtons() debe devolver el botón del ratón correspondiente.

El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si se reimplementa esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::mouseUngrabEvent()

Este manejador de eventos puede ser reimplementado en una subclase para ser notificado cuando un evento de desenganche del ratón ha ocurrido en este ítem.

[invokable] QQuickItem *QQuickItem::nextItemInFocusChain(bool forward = true)

Devuelve el elemento de la cadena de enfoque que se encuentra junto a este elemento. Si forward es true, o no se proporciona, es el siguiente elemento en la dirección hacia delante. Si forward es false, es el siguiente elemento en la dirección hacia atrás.

Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

void QQuickItem::polish()

Programa un evento de pulido para este elemento.

Cuando el gráfico de escena procese la solicitud, llamará a updatePolish() en este elemento.

Ver también updatePolish(), QQuickTest::qIsPolishScheduled(), y ensurePolished().

[virtual protected] void QQuickItem::releaseResources()

Se llama a esta función cuando un elemento debe liberar recursos gráficos que aún no están gestionados por los nodos devueltos por QQuickItem::updatePaintNode().

Esto ocurre cuando el elemento está a punto de ser eliminado de la ventana en la que se estaba renderizando previamente. Se garantiza que el elemento tiene un window cuando se llama a la función.

La función es llamada en el hilo GUI y el estado del hilo de renderizado, cuando se utiliza, es desconocido. Los objetos no deben borrarse directamente, sino programarse para su limpieza utilizando QQuickWindow::scheduleRenderJob().

Véase también Graphics Resource Handling.

QQuickItem *QQuickItem::scopedFocusItem() const

Si este elemento es un ámbito de foco, devuelve el elemento de su cadena de foco que actualmente tiene foco.

Devuelve nullptr si este elemento no es un ámbito de enfoque.

void QQuickItem::setAcceptHoverEvents(bool enabled)

Si enabled es verdadero, el elemento acepta eventos hover; en caso contrario, no acepta eventos hover.

Véase también acceptHoverEvents().

void QQuickItem::setAcceptTouchEvents(bool enabled)

Si enabled es verdadero, el elemento acepta eventos táctiles; en caso contrario, no acepta eventos táctiles.

Véase también acceptTouchEvents().

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

Establece los botones del ratón aceptados por este elemento en buttons.

Nota: En Qt 5, llamar a setAcceptedMouseButtons() causaba implícitamente que un elemento recibiera eventos táctiles así como eventos de ratón; pero se recomendaba llamar a setAcceptTouchEvents() para suscribirse a ellos. En Qt 6, es necesario llamar a setAcceptTouchEvents() para seguir recibiéndolos.

Véase también acceptedMouseButtons().

void QQuickItem::setCursor(const QCursor &cursor)

Establece la forma cursor para este elemento.

Véase también cursor() y unsetCursor().

void QQuickItem::setFiltersChildMouseEvents(bool filter)

Establece si los eventos de puntero destinados a los elementos hijos de este elemento deben filtrarse a través de este elemento.

Si filter es verdadero, se llamará a childMouseEventFilter() cuando se active un evento de puntero para un elemento hijo.

Véase también filtersChildMouseEvents().

void QQuickItem::setFlag(QQuickItem::Flag flag, bool enabled = true)

Activa el indicador flag especificado para este elemento si enabled es verdadero; si enabled es falso, el indicador se desactiva.

Proporcionan varias sugerencias para el elemento; por ejemplo, la bandera ItemClipsChildrenToShape indica que todos los hijos de este elemento deben recortarse para que quepan dentro del área del elemento.

void QQuickItem::setFlags(QQuickItem::Flags flags)

Habilita el flags especificado para este elemento.

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

void QQuickItem::setFocusPolicy(Qt::FocusPolicy policy)

Establece la política de enfoque de este elemento en policy.

Nota: Función Setter para la propiedad focusPolicy.

Véase también focusPolicy().

void QQuickItem::setKeepMouseGrab(bool keep)

Establece si la entrada del ratón debe permanecer exclusivamente con este elemento.

Esto es útil para elementos que desean agarrar y mantener la interacción del ratón siguiendo un gesto predefinido. Por ejemplo, un elemento que está interesado en el movimiento horizontal del ratón puede establecer keepMouseGrab a true una vez que se ha superado un umbral. Una vez que keepMouseGrab se ha establecido en true, los elementos de filtrado no reaccionarán a los eventos del ratón.

Si keep es falso, un elemento de filtrado puede robar el agarre. Por ejemplo, Flickable puede intentar robar una captura del ratón si detecta que el usuario ha empezado a mover la ventana gráfica.

Véase también keepMouseGrab().

void QQuickItem::setKeepTouchGrab(bool keep)

Establece si los puntos táctiles capturados por este elemento deben permanecer exclusivamente con este elemento.

Esto es útil para elementos que desean agarrar y mantener puntos táctiles específicos siguiendo un gesto predefinido. Por ejemplo, un elemento interesado en el movimiento horizontal de los puntos táctiles puede establecer setKeepTouchGrab en true una vez superado un umbral. Una vez que setKeepTouchGrab se ha establecido en true, los elementos de filtrado no reaccionarán a los puntos táctiles relevantes.

Si keep es falso, un elemento filtrante puede robar el agarre. Por ejemplo, Flickable puede intentar robar la captura de un punto táctil si detecta que el usuario ha empezado a mover la ventana gráfica.

Véase también keepTouchGrab() y setKeepMouseGrab().

void QQuickItem::setSize(const QSizeF &size)

Establece el tamaño del elemento en size. Este método conserva cualquier vinculación existente sobre la anchura y la altura; por lo tanto, cualquier cambio que provoque que la vinculación se ejecute de nuevo anulará los valores establecidos.

Véase también size, setWidth, y setHeight.

QSizeF QQuickItem::size() const

Devuelve el tamaño del elemento.

Véase también setSize, width, y height.

void QQuickItem::stackAfter(const QQuickItem *sibling)

Mueve este elemento al índice posterior al elemento hermano especificado dentro de la lista de hijos. El orden de los hijos afecta tanto al orden de apilamiento visual como al orden de navegación del foco de la pestaña.

Asumiendo que los valores z de ambos elementos son los mismos, esto hará que sibling se muestre debajo de este elemento.

Si ambos elementos tienen activeFocusOnTab establecido en true, esto también causará que el orden de enfoque de la pestaña cambie, con sibling recibiendo el enfoque antes que este elemento.

El sibling dado debe ser un hermano de este elemento; es decir, deben tener el mismo parent inmediato.

Véase también Conceptos - Visual Parent en Qt Quick.

void QQuickItem::stackBefore(const QQuickItem *sibling)

Mueve este elemento al índice anterior al elemento hermano especificado dentro de la lista de hijos. El orden de los elementos secundarios afecta tanto al orden de apilamiento visual como al orden de navegación de las pestañas.

Asumiendo que los valores z de ambos elementos son los mismos, esto hará que sibling se muestre por encima de este elemento.

Si ambos elementos tienen activeFocusOnTab establecido en true, esto también hará que el orden de enfoque de la pestaña cambie, con sibling recibiendo el enfoque después de este elemento.

El sibling dado debe ser un hermano de este elemento; es decir, deben tener el mismo parent inmediato.

Véase también Conceptos - Visual Parent en Qt Quick.

[virtual] QSGTextureProvider *QQuickItem::textureProvider() const

Devuelve el proveedor de textura de un elemento. La implementación por defecto devuelve nullptr.

Esta función sólo puede ser llamada en el hilo de renderizado.

[virtual protected] void QQuickItem::touchEvent(QTouchEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos táctiles de un ítem. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[virtual protected] void QQuickItem::touchUngrabEvent()

Este manejador de eventos puede ser reimplementado en una subclase para ser notificado cuando un evento de desasimiento táctil ha ocurrido en este ítem.

void QQuickItem::unsetCursor()

Borra la forma del cursor para este elemento.

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

[slot] void QQuickItem::update()

Programa una llamada a updatePaintNode() para este elemento.

La llamada a QQuickItem::updatePaintNode() siempre se producirá si el elemento se muestra en QQuickWindow.

Sólo los elementos que especifican QQuickItem::ItemHasContents pueden llamar a QQuickItem::update().

[protected] void QQuickItem::updateInputMethod(Qt::InputMethodQueries queries = Qt::ImQueryInput)

Notifica al método de entrada los valores de consulta actualizados si es necesario. queries indica los atributos modificados.

[virtual protected] QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *updatePaintNodeData)

Llamada en el hilo de renderizado cuando es el momento de sincronizar el estado del ítem con el gráfico de escena.

La función es llamada como resultado de QQuickItem::update(), si el usuario ha establecido la bandera QQuickItem::ItemHasContents en el elemento.

La función debe devolver la raíz del subárbol del grafo de escena para este elemento. La mayoría de las implementaciones devolverán un único QSGGeometryNode que contiene la representación visual de este elemento. oldNode es el nodo que se devolvió la última vez que se llamó a la función. updatePaintNodeData proporciona un puntero al QSGTransformNode asociado con este QQuickItem.

QSGNode *MyItem::updatePaintNode(QSGNode *node, UpdatePaintNodeData *)
{
    QSGSimpleRectNode *n = static_cast<QSGSimpleRectNode *>(node);
    if (!n) {
        n = new QSGSimpleRectNode();
        n->setColor(Qt::red);
    }
    n->setRect(boundingRect());
    return n;
}

El hilo principal está bloqueado mientras se ejecuta esta función, por lo que es seguro leer valores de la instancia QQuickItem y otros objetos en el hilo principal.

Si ninguna llamada a QQuickItem::updatePaintNode() resulta en cambios reales en el gráfico de la escena, como QSGNode::markDirty() o añadir y eliminar nodos, entonces la implementación subyacente puede decidir no renderizar la escena de nuevo ya que el resultado visual es idéntico.

Advertencia: Es crucial que las operaciones gráficas y la interacción con el grafo de escena ocurran exclusivamente en el hilo de renderizado, principalmente durante la llamada a QQuickItem::updatePaintNode(). La mejor regla es usar solo clases con el prefijo "QSG" dentro de la función QQuickItem::updatePaintNode().

Advertencia: Esta funcion es llamada en el hilo de renderizado. Esto significa que cualquier QObjects o hilo de almacenamiento local que se cree tendrá afinidad con el hilo de renderizado, así que ten cuidado cuando hagas algo que no sea renderizar en esta función. De manera similar para las señales, estas serán emitidas en el hilo de renderizado y por lo tanto a menudo serán entregadas a través de conexiones en cola.

Nota: Todas las clases con el prefijo QSG deben ser usadas únicamente en el hilo de renderizado del gráfico de escena. Ver Gráfico de Escena y Renderizado para más información.

Véase también QSGMaterial, QSGGeometryNode, QSGGeometry, QSGFlatColorMaterial, QSGTextureMaterial, QSGNode::markDirty(), y Graphics Resource Handling.

[virtual protected] void QQuickItem::updatePolish()

Esta función debe realizar cualquier diseño que se requiera para este elemento.

Cuando se llama a polish(), el gráfico de escena programa un evento de pulido para este elemento. Cuando el grafo de escena está listo para renderizar este ítem, llama a updatePolish() para realizar cualquier diseño requerido antes de renderizar el siguiente cuadro.

Véase también ensurePolished().

QQuickItem *QQuickItem::viewportItem() const

Si la opción ItemObservesViewport está activada, devuelve el elemento padre más cercano con la opción ItemIsViewport. Devuelve el elemento de contenido de la ventana si la bandera no está activada, o si no se encuentra ningún otro elemento de la ventana gráfica.

Devuelve nullptr sólo si no hay ningún elemento en la ventana gráfica y este elemento no se muestra en una ventana.

Véase también clipRect().

[virtual protected] void QQuickItem::wheelEvent(QWheelEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de rueda para un ítem. La información del evento es proporcionada por el parámetro event.

El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().

[protected] bool QQuickItem::widthValid() const

Devuelve si la propiedad width se ha establecido explícitamente.

QQuickWindow *QQuickItem::window() const

Devuelve la ventana en la que se representa este elemento.

El elemento no tiene una ventana hasta que ha sido asignado a una escena. La señal windowChanged() proporciona una notificación tanto cuando el elemento se introduce en una escena como cuando se elimina de una escena.

[signal] void QQuickItem::windowChanged(QQuickWindow *window)

Esta señal se emite cuando cambia la dirección window del artículo.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.