En esta página

QQuickItem Class

La clase QQuickItem ofrece el elemento visual más básico de todos en Qt Quick. Más...

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

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 }
(since 6.12) enum MutabilityGroup { AutoMutabilityGroup, StaticMutabilityGroup, ModerateMutabilityGroup, DynamicMutabilityGroup }
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
int mutabilityGroup() 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 setMutabilityGroup(int mutabilityGroup)
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 containmentMaskChanged()
void windowChanged(QQuickWindow *window)

Funciones protegidas

virtual bool 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
virtual void 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 comunes a los elementos visuales, como la posición x e y, la anchura y la altura, el anclaje y la compatibilidad con el manejo de teclas.

Puedes crear una subclase de QQuickItem para proporcionar tu propio elemento visual personalizado que herede estas características.

Elementos personalizados del grafo de escena

Todos los elementos visuales de QML se representan mediante el grafo de escena, cuya implementación por defecto es una pila de representación de bajo nivel y alto rendimiento, estrechamente vinculada a las API gráficas aceleradas, como OpenGL, Vulkan, Metal o Direct 3D. Las subclases de `QQuickItem` pueden añadir su propio contenido personalizado al grafo de escena estableciendo el indicador ` QQuickItem::ItemHasContents ` y reimplementando la función ` QQuickItem::updatePaintNode()`.

Advertencia: Es fundamental que las operaciones gráficas y la interacción con el grafo de escena se realicen exclusivamente en el hilo de renderizado, sobre todo 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 hilo de renderizado del grafo de escena. Consulta «Grafo de escena y renderizado» para obtener más información.

Gestión de recursos gráficos

La forma recomendada de gestionar la limpieza de los recursos gráficos utilizados en el grafo de escena es confiar en la limpieza automática de los nodos. Un objeto ` QSGNode ` devuelto por ` QQuickItem::updatePaintNode()` se elimina automáticamente en el hilo adecuado y en el momento oportuno. Los árboles de instancias de ` QSGNode ` se gestionan mediante el uso de ` QSGNode::OwnedByParent`, que está activado por defecto. Por lo tanto, para la mayoría de los elementos personalizados del grafo de escena, no se requerirá ningún trabajo adicional.

Las implementaciones que almacenan recursos gráficos fuera del árbol de nodos, como un elemento que implemente ` QQuickItem::textureProvider()`, deberán asegurarse de limpiarlos correctamente en función de cómo se utilice el elemento en QML. Las situaciones que hay que tener en cuenta son:

  • El grafo de escena queda invalidado; esto puede ocurrir, dependiendo de la plataforma y de la configuración de QQuickWindow, cuando la ventana se oculta mediante QQuickWindow::hide(), o cuando se cierra. Si la clase del elemento implementa un slot denominado invalidateSceneGraph(), este slot se llamará en el hilo de renderizado mientras el hilo de la GUI está bloqueado. Esto equivale a conectarse a QQuickWindow::sceneGraphInvalidated(). Al renderizar mediante 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 se ha destruido fuera del control de Qt, por ejemplo, mediante EGL_CONTEXT_LOST.
  • El elemento se elimina de la escena; si un elemento se retira de la escena, por ejemplo, porque su padre se ha establecido en null o porque es un elemento de otra ventana, se llamará a QQuickItem::releaseResources() en el hilo de la interfaz gráfica de usuario. Se debe utilizar QQuickWindow::scheduleRenderJob() para programar la limpieza de los recursos de renderizado.
  • El elemento se elimina; cuando se ejecuta el destructor de un elemento, este debe eliminar cualquier recurso gráfico que tenga. Si aún no se ha cumplido 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(), el elemento, en muchos casos, ya no tendrá acceso a un QQuickWindow y, por lo tanto, no dispondrá de ningún medio para programar la limpieza.

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

Nota: Se desaconseja encarecidamenteel uso de ` QObject::deleteLater()` para liberar 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 QPainter personalizados

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

Advertencia: El uso de ` QQuickPaintedItem ` recurre a una superficie 2D indirecta para renderizar su contenido, mediante rasterización por software, por lo que el renderizado es una operación en dos pasos. Primero se rasteriza la superficie y, a continuación, se dibuja. Utilizar directamente la API del grafo de escena siempre resulta significativamente más rápido.

Animaciones de comportamiento

Si tu elemento utiliza el tipo ` Behavior ` para definir animaciones ante cambios en las propiedades, debes utilizar siempre ` QObject::setProperty()`, `QQmlProperty()` o ` QMetaProperty::write()` cuando necesites modificar dichas propiedades desde C++. Esto garantiza que el motor QML detecte el cambio en la propiedad. De lo contrario, el motor no podrá ejecutar la animación solicitada. Ten en cuenta que estas funciones suponen una ligera pérdida de rendimiento. Para obtener más detalles, consulta Acceso a los miembros de un tipo de objeto QML desde C++.

Véase también « QQuickWindow » y « QQuickPaintedItem ».

Documentación sobre tipos de miembros

enum QQuickItem::Flag
flags QQuickItem::Flags

Este tipo de enumeración se utiliza para especificar diversas propiedades de los elementos.

ConstanteValorDescripción
QQuickItem::ItemClipsChildrenToShape0x01Indica que este elemento debe recortar visualmente sus elementos secundarios para que se muestren únicamente dentro de los límites de este elemento.
QQuickItem::ItemAcceptsInputMethod0x02Indica que el elemento admite métodos de entrada de texto.
QQuickItem::ItemIsFocusScope0x04Indica que el elemento es un ámbito de foco. Para obtener más información, consulta «Foco del teclado» en Qt Quick.
QQuickItem::ItemHasContents0x08Indica que el elemento tiene contenido visual y debe ser renderizado por el grafo de escena.
QQuickItem::ItemAcceptsDrops0x10Indica que el elemento acepta eventos de arrastrar y soltar.
QQuickItem::ItemIsViewport0x20Indica que el elemento define una ventana de visualización para sus elementos secundarios.
QQuickItem::ItemObservesViewport0x40Indica que el elemento desea conocer los límites de la ventana de visualización cuando algún antepasado tiene activado el indicador ItemIsViewport.

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

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

enum QQuickItem::ItemChange

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

ConstanteValorDescripción
QQuickItem::ItemChildAddedChange0Se ha añadido un elemento secundario. ItemChangeData::item contiene el elemento secundario añadido.
QQuickItem::ItemChildRemovedChange1Se ha eliminado un elemento secundario. ItemChangeData::item contiene el elemento secundario eliminado.
QQuickItem::ItemSceneChange2El elemento se ha añadido a una escena o se ha eliminado de ella. El ` QQuickWindow ` que representa la escena se especifica mediante ` ItemChangeData::window`. El parámetro `window` 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 elemento padre del elemento ha cambiado. ItemChangeData::item contiene el nuevo elemento padre.
QQuickItem::ItemOpacityHasChanged5La opacidad del elemento ha cambiado. ItemChangeData::realValue contiene la nueva opacidad.
QQuickItem::ItemActiveFocusHasChanged6El foco del elemento ha cambiado. ItemChangeData::boolValue indica si el elemento tiene el foco o no.
QQuickItem::ItemRotationHasChanged7La rotación del elemento ha cambiado. ` ItemChangeData::realValue ` contiene la nueva rotación.
QQuickItem::ItemDevicePixelRatioHasChanged9La relació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 suavizado se ha modificado. El valor actual (booleano) se puede encontrar en ` QQuickItem::antialiasing`.
QQuickItem::ItemEnabledHasChanged10El estado de activación del elemento ha cambiado. ItemChangeData::boolValue contiene el nuevo estado de activación. (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 cambian la posición, el tamaño, la rotación, la escala, transformOrigin o las transformaciones asociadas del elemento. ItemChangeData::item contiene el elemento que ha provocado el cambio. (desde Qt 6.9)

[since 6.12] enum QQuickItem::MutabilityGroup

Esta enumeración proporciona valores predefinidos que pueden utilizarse para la propiedad « mutabilityGroup ».

ConstanteValorDescripción
QQuickItem::AutoMutabilityGroup0x0El grupo de mutabilidad predeterminado.
QQuickItem::StaticMutabilityGroup0x1Indica que el elemento se actualiza muy raramente o nunca.
QQuickItem::ModerateMutabilityGroup0x8Indica que el elemento se actualiza con una frecuencia moderada.
QQuickItem::DynamicMutabilityGroup0xfIndica que el elemento se actualiza con frecuencia o en cada fotograma.

Esta enumeración se introdujo en Qt 6.12.

enum QQuickItem::TransformOrigin

Controla el punto en torno al cual se aplican transformaciones simples, como el cambio de escala.

ConstanteValorDescripción
QQuickItem::TopLeft0La esquina superior izquierda del elemento.
QQuickItem::Top1El punto central de la parte superior del elemento.
QQuickItem::TopRight2La esquina superior derecha del elemento.
QQuickItem::Left3El punto más a la izquierda de la línea central vertical.
QQuickItem::Center4El centro del elemento.
QQuickItem::Right5El punto más a la derecha de la línea central 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 solo lectura indica si el elemento tiene el foco activo.

Si `activeFocus` es `true`, o bien este elemento es el que recibe actualmente la entrada del teclado, o bien es un antepasado de tipo ` FocusScope ` del elemento que recibe actualmente la entrada del teclado.

Normalmente, se obtiene el «activeFocus» estableciendo « focus » en un elemento y en sus objetos « FocusScope » contenedores. En el siguiente ejemplo, los objetos « input » y « focusScope » tendrán el foco activo, mientras que el objeto «rectangle» 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

Véase también « focus » y «Foco del teclado» en Qt Quick.

activeFocusOnTab : bool

Esta propiedad determina si el elemento desea formar parte de la cadena de enfoque de las pestañas. Por defecto, está configurada en « false ».

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

Funciones de acceso:

bool activeFocusOnTab() const
void setActiveFocusOnTab(bool)

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

antialiasing : bool

Especifica si el elemento tiene suavizado o no

Lo utilizan los elementos visuales para decidir si el elemento debe aplicar suavizado o no. En algunos casos, los elementos con suavizado requieren más memoria y su renderizado puede ser más lento (véase Suavizado para obtener más detalles).

El valor por defecto es «false», pero los elementos derivados pueden anularlo.

Funciones de acceso:

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

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 establecer su línea de base en la línea de base de su texto.

Para los elementos que no son de texto, se utiliza un desplazamiento predeterminado de la línea de base de 0.

Funciones de Access:

qreal baselineOffset() const
void setBaselineOffset(qreal)

[read-only] childrenRect : QRectF

Esta propiedad contiene la posición y el tamaño colectivos de los elementos secundarios del elemento.

Esta propiedad resulta útil si necesitas acceder a la geometría colectiva de los elementos secundarios de un elemento para dimensionarlo correctamente.

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()

clip : bool

Esta propiedad indica si el recorte está activado. El valor predeterminado del recorte es « false ».

Si el recorte está activado, un elemento recortará su propio dibujo, así como el de sus elementos secundarios, a su rectángulo delimitador. Si se establece el recorte durante la operación de dibujo de un elemento, hay que recordar restablecerlo para evitar que se recorte el resto de la escena.

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

Nota: Por motivos relacionados con QML, al establecer «clip» en « true » también se activa el indicador « ItemIsViewport », lo que en ocasiones actúa como una optimización: los elementos hijos que tengan el indicador « ItemObservesViewport » pueden prescindir de crear nodos del grafo de escena que queden fuera del área de visualización. No obstante, el indicador « ItemIsViewport » también se puede establecer de forma independiente.

Funciones de acceso:

bool clip() const
void setClip(bool)

containmentMask : QObject*

Esta propiedad contiene una máscara opcional que se utiliza en el método ` contains()`, el cual se emplea principalmente para realizar pruebas de colisión con cada ` QPointerEvent`.

Por defecto, ` contains()` devolverá ` true ` para cualquier punto dentro del rectángulo delimitador del elemento. Sin embargo, 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 delegar la comprobación de colisión a ese objeto.

Nota: La función ` contains()` se invoca con frecuencia durante la entrega de eventos. Trasladar la comprobación de colisiones a otro objeto ralentiza ligeramente el proceso. La función `containmentMask()` puede provocar problemas de rendimiento si el método ` contains()` de dicho objeto no es eficiente. Si implementas una subclase personalizada de ` QQuickItem `, también puedes sobrescribir la función ` contains()`.

Funciones de acceso:

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

Señal del notificador:

void containmentMaskChanged()

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

enabled : bool

Esta propiedad indica si el elemento recibe eventos del ratón y del teclado. Por defecto, su valor es «true».

Al configurar esta propiedad, se afecta directamente al valor de « enabled » de los elementos secundarios. Cuando se establece en « false », los valores de « enabled » de todos los elementos secundarios también pasan a ser « false ». Cuando se establece en « true », los valores de « enabled » de los elementos secundarios vuelven a ser « true », a menos que se hayan establecido explícitamente en « false ».

Al establecer esta propiedad en « false », se establece automáticamente « activeFocus » en « false », y este elemento dejará de recibir eventos de teclado.

Nota: Los eventosde desplazamiento del cursor se habilitan por separado mediante ` setAcceptHoverEvents()` (). Por lo tanto, un elemento desactivado puede seguir recibiendo eventos de desplazamiento del cursor, incluso cuando esta propiedad sea ` false`. Esto permite mostrar información de retroalimentación (como ` ToolTip`) incluso cuando un elemento interactivo esté desactivado. Lo mismo se aplica a cualquier ` HoverHandlers ` añadido como elemento secundario del elemento. Sin embargo, un « HoverHandler » puede desactivarse explícitamente mediante « disabled » o, por ejemplo, vincularse al estado « enabled » del elemento.

Funciones de acceso:

bool isEnabled() const
void setEnabled(bool)

Véase también visible.

focus : bool

Esta propiedad indica si el elemento tiene el foco dentro del elemento FocusScope que lo contiene. Si el valor es «true», este elemento obtendrá el foco activo cuando el elemento FocusScope que lo contiene obtenga el foco activo.

En el siguiente ejemplo, input recibirá el foco activo cuando scope obtenga el 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. En la práctica, esto significa que el siguiente código QML otorgará el 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)

Véase también activeFocus y «Foco del teclado» en Qt Quick.

[since 6.7] focusPolicy : Qt::FocusPolicy

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

Esta enumeración se introdujo en Qt 6.7.

Funciones de acceso:

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

[bindable] height : qreal

Nota: Esta propiedad admite enlaces de tipo « QProperty ».

Esta propiedad contiene la altura de este elemento.

Funciones de acceso:

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

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, este determinará el tamaño preferido del elemento utilizando su tamaño implícito. En tal caso, se ignorarán los valores explícitos 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 se puede anular, por ejemplo, Image y Text.

Establecer el tamaño implícito resulta útil para definir componentes que tienen un tamaño preferido en función de 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: El uso de implicitWidth, Text o TextEdit y la configuración explícita del ancho conlleva una pérdida de rendimiento, ya que el texto debe maquetarse dos veces.

[since 6.12] mutabilityGroup : int

Indicador para el renderizador sobre la frecuencia de los cambios en un elemento

Se trata de una propiedad avanzada que puede utilizarse para optimizaciones de bajo nivel. Sirve como indicación para el renderizador sobre la frecuencia con la que se actualizará un elemento. En los casos de uso habituales, bastará con dejar esta propiedad en su valor por defecto (QQuickItem::AutoMutabilityGroup (0)).

Sin embargo, en determinados casos, un análisis del rendimiento puede revelar cuellos de botella que el comportamiento por defecto del renderizador de grafos de escena Qt Quick no ha podido optimizar. Normalmente, esto puede ocurrir si la geometría que se actualiza rápidamente se agrupa junto con geometría estática. Para evitarlo, puede, por ejemplo, intentar asignar los componentes que se actualizan rápidamente a QQuickItem::DynamicMutabilityGroup. La geometría de diferentes grupos de mutabilidad no se agrupará.

El grupo de mutabilidad solo se aplica al propio elemento. No se propaga a los hijos.

Consulta «Renderizador predeterminado del grafo de escena deQt Quick » para obtener más información sobre el funcionamiento interno del renderizador del grafo de escena « Qt Quick » y el agrupamiento de geometría.

Nota: El rango numérico válido de los grupos de mutabilidad es [0 .. 15]. La propiedad se limitará a este rango. Por convención, se espera que la frecuencia aumente con el valor numérico del grupo.

Esta enumeración se introdujo en Qt 6.12.

Funciones de acceso:

int mutabilityGroup() const
void setMutabilityGroup(int mutabilityGroup)

opacity : qreal

Esta propiedad define la opacidad del elemento. La opacidad se especifica como un número comprendido 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 secundarios. Esto puede tener un efecto no deseado en algunas circunstancias. Por ejemplo, en el segundo conjunto de rectángulos que se muestra a continuación, el rectángulo rojo tiene especificada una opacidad de 0,5, lo que afecta a la opacidad de su rectángulo secundario azul, aunque este último no tenga especificada ninguna opacidad.

Los valores fuera del rango de 0 a 1 se limitarán.

Rectángulos rojos y azules con opacidad total

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

Los rectángulos rojos y azules son ambos semitransparentes debido a la opacidad de 0,5 del elemento padre.

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 su capacidad para recibir eventos de entrada del usuario. (Por el contrario, establecer la propiedad visible en false detiene los eventos del ratón, y establecer la propiedad enabled en false detiene los eventos del ratón y del teclado, además de eliminar el foco activo del elemento).

Funciones de Access:

qreal opacity() const
void setOpacity(qreal)

Véase también visible.

parent : QQuickItem*

Esta propiedad contiene el padre visual del elemento.

Nota: El concepto de «padre visual » difiere del de «padre eQObject ». El padre visual de un elemento no tiene por qué ser necesariamente el mismo que su padre e . Para más detalles, véase «Conceptos - Padre visual» en Qt Quick.

Nota: La señal de notificación de esta propiedad se emite durante la destrucción del padre visual. Los controladores de señales de C++ no pueden dar por sentado que los elementos de la jerarquía del padre visual sigan estando completamente construidos. Utiliza ` qobject_cast ` para verificar que los elementos de la jerarquía del padre se pueden utilizar de forma segura como el tipo esperado.

Funciones de acceso:

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

rotation : qreal

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

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

Cuadrado rojo girado 30 grados dentro de un cuadrado azul

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)

Véase también « Transform » y « Rotation ».

scale : qreal

Esta propiedad contiene el factor de escala de este elemento.

Una escala inferior a 1,0 hace que el elemento se represente con un tamaño menor, mientras que una escala superior a 1,0 lo representa con un tamaño mayor. Una escala negativa hace que el elemento se refleje al representarlo.

El valor por defecto es 1,0.

El escalado se aplica desde el ` transformOrigin`.

Cuadrados azules y rojos con un tamaño y una posición concretos

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)

Véase también Transform y Scale.

smooth : bool

Especifica si el elemento se suaviza o no

Se utiliza principalmente en elementos basados en imágenes para decidir si el elemento debe emplear muestreo suavizado o no. El muestreo suavizado se realiza mediante interpolación lineal, mientras que el no suavizado se realiza mediante el método del vecino más cercano.

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

De forma predeterminada, esta propiedad está configurada en « true ».

Funciones de acceso:

bool smooth() const
void setSmooth(bool)

state : QString

Esta propiedad contiene el nombre del estado actual del elemento.

Si el elemento se encuentra en su estado predeterminado, es decir, si no se ha establecido ningún estado explícito, esta propiedad contiene una cadena vacía. Del mismo modo, puedes restablecer un elemento a su estado predeterminado estableciendo esta propiedad en una cadena vacía.

Funciones de acceso:

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

Véase también «Estadosde Qt Quick ».

transformOrigin : TransformOrigin

Esta propiedad define el punto de origen en torno al cual se realizan las transformaciones de escala y rotación.

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

Rectángulo que muestra nueve puntos de origen de transformación: ArribaIzquierda, Arriba, ArribaDerecha, Izquierda, Centro, Derecha, AbajoIzquierda, Abajo, AbajoDerecha

Funciones de acceso:

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

visible : bool

Esta propiedad indica si el elemento está visible. Por defecto, su valor es «true».

Al establecer esta propiedad, se afecta directamente al valor de « visible » de los elementos secundarios. Cuando se establece en « false », los valores de « visible » de todos los elementos secundarios también pasan a ser « false ». Cuando se establece en « true », los valores de « visible » de los elementos secundarios vuelven a ser « true », a menos que se hayan establecido explícitamente en « false ».

(Debido a este comportamiento en cadena, el uso de la propiedad visible puede no tener el efecto deseado si un enlace de propiedad solo debe responder a cambios explícitos en la 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 del ratón, pero seguirá recibiendo eventos de teclado y conservará la propiedad « focus » del teclado si se ha establecido. (Por el contrario, establecer la propiedad « enabled » en « false » detiene tanto los eventos del ratón como los del teclado, y además retira el foco del elemento.)

Nota: El valor deesta propiedad solo se ve afectado por cambios en la propia propiedad o en la propiedad « visible » del elemento padre. No cambia, por ejemplo, si este elemento se desplaza fuera de la pantalla o si el « opacity » cambia a 0. Sin embargo, por razones históricas, esta propiedad es «true» tras la construcción del elemento, incluso si aún no se ha añadido a una escena. Modificar o leer esta propiedad de un elemento que no se ha 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 padre visual. Los controladores de señales de C++ no pueden dar por sentado que los elementos de la jerarquía del padre visual sigan estando completamente construidos. Utiliza ` qobject_cast ` para verificar que los elementos de la jerarquía del padre pueden utilizarse de forma segura como el tipo esperado.

Funciones de acceso:

bool isVisible() const
void setVisible(bool)

Véase también opacity y enabled.

[bindable] width : qreal

Nota: Esta propiedad admite enlaces de tipo « QProperty ».

Esta propiedad contiene el ancho de este elemento.

Funciones de acceso:

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

[bindable] x : qreal

Nota: Esta propiedad admite enlaces de tipo « QProperty ».

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

Funciones de acceso:

qreal x() const
void setX(qreal)

[bindable] y : qreal

Nota: Esta propiedad admite enlaces de tipo « QProperty ».

Define la posición en el eje Y del elemento con respecto a su elemento padre.

Funciones de acceso:

qreal y() const
void setY(qreal)

z : qreal

Establece el orden de superposición de los elementos hermanos. Por defecto, el orden de superposición es 0.

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

El siguiente ejemplo muestra los distintos efectos del orden de superposición.

Rectángulo azul sobre uno rojo; más tarde, el hermano se colocó encima

Mismo « z »: los hijos posteriores aparecen encima de los anteriores:
Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

El rectángulo rojo que está encima del azul; el que tiene el valor z más alto se superpone

z o más alto en la parte superior:
Item {
    Rectangle {
        z: 1
        color: "red"
        width: 100; height: 100
    }
    Rectangle {
        color: "blue"
        x: 50; y: 50; width: 100; height: 100
    }
}

Rectángulo azul encima del rojo; el elemento secundario se superpone al principal

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

Rectángulo rojo sobre el azul; el valor z negativo se apila debajo del elemento principal

z inferior, abajo:
Item {
    Rectangle {
        color: "red"
        width: 100; height: 100
        Rectangle {
            z: -1
            color: "blue"
            x: 50; y: 50; width: 100; height: 100
        }
    }
}

Funciones de Access:

qreal z() const
void setZ(qreal)

Documentación de las funciones de miembro

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

Crea un objeto `QQuickItem` con el ` parent` indicado.

El ` parent ` se utilizará tanto como padre de ` visual parent ` como de ` QObject `.

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

Destruye el « QQuickItem ».

bool QQuickItem::acceptHoverEvents() const

Indica si este elemento admite eventos de desplazamiento del cursor.

El valor por defecto es «false».

Si es «false», el elemento no recibirá ningún evento de desplazamiento del cursor a través de las funciones hoverEnterEvent(), hoverMoveEvent() y hoverLeaveEvent().

Véase también setAcceptHoverEvents().

bool QQuickItem::acceptTouchEvents() const

Indica si este elemento admite eventos táctiles.

El valor predeterminado es ` false`.

Si es false, 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 que admite 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 concreto del ratón, dicho evento no se transmitirá a ese elemento, sino que se transmitirá al siguiente elemento de la jerarquía.

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

[virtual] QRectF QQuickItem::boundingRect() const

Devuelve los límites del elemento en su propio sistema de coordenadas: un rectángulo que va de 0, 0 a width() y height().

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

Devuelve el primer elemento secundario visible que se encuentre en el punto (x, y) dentro del sistema de coordenadas de este elemento.

Devuelve ` nullptr ` si no existe dicho elemento.

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

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

Devuelve los elementos secundarios de este elemento.

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

Reimplementa este método para filtrar los eventos de puntero que reciben los elementos secundarios de este elemento.

Este método solo se llamará si filtersChildMouseEvents() es true.

Devuelve ` true ` si el ` event ` especificado no debe transmitirse al elemento hijo especificado ` item`, y ` false ` en caso contrario. Si devuelves ` true`, también debes ` accept ` o ` ignore ` el ` event`, para indicar si la propagación del evento debe detenerse o continuar. Sin embargo, el ` event ` siempre se enviará a todos los `childMouseEventFilters` en la cadena ascendente de padres.

Nota: A pesar de su nombre, esta función filtra todas las instancias de QPointerEvent durante su entrega a todos los hijos (normalmente eventos de ratón, táctiles y de tableta). Al sobrescribir esta función en una subclase, recomendamos escribir código genérico de gestión de eventos utilizando únicamente los accesores que se encuentran en QPointerEvent. Como alternativa, puedes activar event->type() y/o event->device()->type() para gestionar diferentes tipos de eventos de distintas maneras.

Nota: El filtrado es solo una forma de compartir la responsabilidad en caso de ambigüedad gestual (por ejemplo, al pulsar, no se sabe si el usuario va a tocar o a arrastrar). Otra forma es llamar a ` QPointerEvent::addPassiveGrabber()` al pulsar, para supervisar de forma no exclusiva el progreso de ` QEventPoint`. En cualquiera de los dos casos, el controlador del elemento o del puntero que está supervisando puede hacerse con el control exclusivo más adelante, cuando quede claro que el gesto se ajusta al patrón que espera.

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 para ejecutarla en `classBegin`.

[virtual] QRectF QQuickItem::clipRect() const

Devuelve el área rectangular dentro de este elemento que está visible actualmente en viewportItem(), si hay una ventana de visualización y está activado el indicador ItemObservesViewport; en caso contrario, devuelve los límites de este elemento en su propio sistema de coordenadas: un rectángulo que va desde 0, 0 hasta width() y height(). Esta es la región que debe permanecer visible si clip es true. También se puede utilizar en updatePaintNode() para limitar los gráficos añadidos al grafo de escena.

Por ejemplo, un dibujo de gran tamaño o un documento de texto extenso podrían mostrarse en un Flickable que ocupe solo una parte de la ventana de la aplicación: en ese caso, Flickable es el elemento de ventana gráfica, y un elemento de renderizado de contenido personalizado puede optar por omitir los nodos del grafo 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 se desplace por el contenido del Flickable.

En el caso de elementos de ventana de visualización anidados, `clipRect()` es la intersección de los ` boundingRect` de todos los antepasados que tengan activado el indicador ` ItemIsViewport `, mapeados 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 que se ejecutarán en `componentComplete`.

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

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

Esta función se puede sobrescribir para gestionar colisiones de puntos en elementos con formas personalizadas. La implementación predeterminada comprueba si el punto se encuentra dentro de ` containmentMask()` si está definido, o dentro del rectángulo delimitador en caso contrario.

Nota: Este método se utiliza para realizar pruebas de colisión con cada QEventPoint durante la entrega de eventos, por lo que la implementación debe ser lo más ligera posible.

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

QCursor QQuickItem::cursor() const

Devuelve la forma del cursor correspondiente a este elemento.

El cursor del ratón adoptará esta forma cuando se sitúe sobre este elemento, a menos que se haya establecido un cursor de sustitución. Consulte list of predefined cursor objects para ver una selección de formas útiles.

Si no se ha establecido ninguna forma de cursor, esta función devuelve un cursor con la forma de Qt::ArrowCursor; sin embargo, puede mostrarse otra forma de cursor si un elemento superpuesto tiene un cursor válido.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos «drag-enter» de un elemento. La información del evento se proporciona a través del parámetro « event ».

Los eventos de arrastrar y soltar solo se proporcionan si se ha establecido el indicador ItemAcceptsDrops para este elemento.

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

Véase también ` Drag ` y «Arrastrar y soltar».

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de «arrastrar y soltar» de un elemento. La información del evento se proporciona a través del parámetro event.

Los eventos de arrastrar y soltar solo se proporcionan si se ha activado el indicador ` ItemAcceptsDrops ` para este elemento.

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

Véase también ` Drag ` y «Arrastrar y soltar».

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de arrastre y desplazamiento de un elemento. La información del evento se proporciona a través del parámetro event.

Los eventos de arrastrar y soltar solo se proporcionan si se ha activado el indicador ` ItemAcceptsDrops ` para este elemento.

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

Véase también ` Drag ` y «Arrastrar y soltar».

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de soltado de un elemento. La información del evento se proporciona a través del parámetro ` event `.

Los eventos de arrastrar y soltar solo se proporcionan si se ha activado el indicador ` ItemAcceptsDrops ` para este elemento.

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

Véase también ` Drag ` y «Arrastrar y soltar».

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

Muestra algunos detalles sobre el árbol visual de los elementos a partir de este elemento, de forma recursiva.

Nota: ` QObject::dumpObjectTree()` muestra un árbol similar; sin embargo, tal y como se explica en «Conceptos - Padre visual» en Qt Quick, el ` QObject::parent()` de un elemento a veces difiere de su ` QQuickItem::parentItem()`. Puedes mostrar ambos árboles para ver la diferencia.

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

Nota: Esta función se puede invocar 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 «Técnicas de depuración » y el «Inspector de Qt Quick » de GammaRay.

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

Llama a updatePolish()

Esto puede resultar útil para elementos como los diseños (o posicionadores), que retrasan el cálculo de sus valores « implicitWidth » y « implicitHeight » hasta que reciben un PolishEvent.

Normalmente, si, por ejemplo, se añade o se elimina un elemento secundario de un «Layout», el tamaño implícito no se calcula de inmediato (se trata de una optimización). En algunos casos, puede ser conveniente consultar el tamaño implícito del diseño justo después de añadir un elemento secundario. Si este es el caso, utiliza esta función justo antes de consultar el tamaño implícito.

Nota: Esta función se puede invocar 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 secundarios de este elemento deben filtrarse a través de este.

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

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

QQuickItem::Flags QQuickItem::flags() const

Devuelve los indicadores de este elemento.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de «focus-in» de un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

Si reimplementas esta función, debes llamar a la implementación de la clase base.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de pérdida de foco de un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

[invokable] void QQuickItem::forceActiveFocus()

Establece el foco en el elemento.

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

El motivo del cambio de foco será Qt::OtherFocusReason. Utiliza el método sobrecargado para especificar el motivo del foco y permitir así una mejor gestión del cambio de foco.

Nota: Esta función se puede invocar 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)

Establece el foco activo en el elemento con la reason indicada.

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

Nota: Esta función se puede invocar 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 se invoca para gestionar los cambios en la geometría de este elemento, desde oldGeometry hasta newGeometry. Si las dos geometrías son iguales, no realiza ninguna acción.

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())

Captura el elemento en una imagen en memoria.

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

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

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 pantalla y copiará dicha superficie de la memoria de la GPU a la memoria de la CPU, lo que puede resultar bastante costoso. Para obtener una vista previa «en directo», utiliza layers o ShaderEffectSource.

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

[protected] bool QQuickItem::heightValid() const

Devuelve si la propiedad «height» se ha establecido de forma explícita.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de entrada al pasar el cursor sobre un elemento. La información del evento se proporciona a través del parámetro ` event `.

Los eventos de paso del cursor solo se proporcionan si acceptHoverEvents() es verdadero.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de entrada y salida del cursor sobre un elemento. La información del evento se proporciona a través del parámetro ` event `.

Los eventos de paso del cursor solo se proporcionan si acceptHoverEvents() es verdadero.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de desplazamiento al pasar el cursor sobre un elemento. La información del evento se proporciona a través del parámetro ` event `.

Los eventos de desplazamiento del cursor solo se proporcionan si acceptHoverEvents() es verdadero.

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

qreal QQuickItem::implicitWidth() const

Devuelve el ancho del elemento que se deduce a partir de otras propiedades que determinan el contenido.

Nota: Funcióngetter para la propiedad implicitWidth.

Véase también setImplicitWidth().

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos del método de entrada de un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

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

Este método solo es relevante para los elementos de entrada.

Si este elemento es un elemento de entrada, este método debe reimplementarse para devolver los indicadores del método de entrada pertinentes para el objeto ` query` dado.

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

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

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

Véase también parentItem().

[protected] bool QQuickItem::isComponentComplete() const

Devuelve «true» si la construcción del componente QML ha finalizado; en caso contrario, devuelve «false».

A menudo es conveniente retrasar parte del procesamiento hasta que el componente se haya completado.

Véase también componentComplete().

bool QQuickItem::isFocusScope() const

Devuelve «true» si este elemento es un visor de enfoque y «false» en caso contrario.

[virtual] bool QQuickItem::isTextureProvider() const

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

Esta función se puede invocar desde cualquier hilo.

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

Se invoca cuando se produce un evento « change » para este elemento.

value Contiene información adicional relacionada con el cambio, cuando proceda.

Si reimplementas este método en una subclase, asegúrate de llamar a

QQuickItem::itemChange(change, value);

normalmente al final de su implementación, para garantizar que se emita la señal ` windowChanged()`.

bool QQuickItem::keepMouseGrab() const

Indica si la entrada del ratón debe limitarse exclusivamente a este elemento.

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

bool QQuickItem::keepTouchGrab() const

Indica si los puntos táctiles capturados por este elemento deben permanecer exclusivamente asociados a él.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de pulsación de teclas correspondientes a un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de liberación de teclas de un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

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

Asigna el valor dado « point » del sistema de coordenadas global de la pantalla al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

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

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

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

Nota: El posicionamientode la ventana lo realiza el gestor de ventanas y este valor se trata únicamente como una sugerencia. Por lo tanto, la posición final de la ventana puede diferir de la esperada.

Nota: Si este elemento se encuentra en una subescena, por ejemplo, asignado a un objeto 3D de tipo « Model », la asignación UV se incorpora a esta transformación, de modo que realmente pasa de las coordenadas de pantalla a las coordenadas de este elemento, siempre y cuando point se encuentre realmente dentro de los límites de este elemento. Las demás funciones de asignación aún no funcionan de esa manera.

Nota: Esta función se puede invocar a través del sistema de metaobjetos 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 valor dado « point » del sistema de coordenadas de « item » al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

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

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

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

Nota: Esta función se puede invocar 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

Asigna la posición « point » dada en el sistema de coordenadas de la escena al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada asignada.

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

Si los elementos forman parte de escenas diferentes, la asignación 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

Asigna el valor « 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 asignado.

En la mapeación se utilizan las siguientes propiedades del elemento: x, y, scale, rotation, transformOrigin y transform.

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

Si item es nullptr, esto asigna rect a partir del sistema de coordenadas de la escena.

Véase también Conceptos: coordenadas visuales en Qt Quick.

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

Asigna el valor « 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 asignado.

En la asignación se utilizan las siguientes propiedades del elemento: ` x`, ` y`, ` scale`, ` rotation`, ` transformOrigin` y ` transform`.

Si los elementos forman parte de escenas diferentes, la correspondencia 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

Asigna el valor « rect » proporcionado 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 asignado.

En la correspondencia se utilizan las siguientes propiedades del elemento: x, y, scale, rotation, transformOrigin y transform.

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

Si ` item ` es ` nullptr`, esto asigna ` 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

Asigna el valor « rect » proporcionado 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 asignado.

En la mapeo se utilizan las siguientes propiedades del elemento: ` x`, ` y`, ` scale`, ` rotation`, ` transformOrigin` y ` transform`.

Si los elementos forman parte de escenas diferentes, la asignación 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

Asigna el valor « point » proporcionado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas global de la pantalla, y devuelve la coordenada asignada.

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

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

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

Nota: El posicionamientode la ventana lo realiza el gestor de ventanas y este valor se trata únicamente como una sugerencia. Por lo tanto, la posición final de la ventana puede diferir de la esperada.

Nota: Esta función se puede invocar a través del sistema de metaobjetos 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 valor dado de « point » en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de « item », y devuelve la coordenada asignada.

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

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

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

Nota: Esta función se puede invocar 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

Asigna el valor dado de « point » en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de la escena, y devuelve la coordenada asignada.

En la asignación se utilizan las siguientes propiedades del elemento: ` x`, ` y`, ` scale`, ` rotation`, ` transformOrigin` y ` transform`.

Si los elementos forman parte de escenas diferentes, la asignación 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 controlador de eventos se puede reimplementar en una subclase para recibir eventos de doble clic del ratón sobre un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de movimiento del ratón para un elemento. La información del evento se proporciona a través del parámetro ` event `.

Para recibir eventos de movimiento del ratón, es necesario aceptar el evento de pulsación del ratón anterior (por ejemplo, sobrescribiendo ` mousePressEvent()`) y ` acceptedMouseButtons()` debe devolver el botón del ratón correspondiente.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de pulsación del ratón para un elemento. La información del evento se proporciona a través del parámetro event.

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

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de liberación del ratón para un elemento. La información del evento se proporciona a través del parámetro ` event `.

Para recibir eventos de liberación del ratón, es necesario aceptar el evento de pulsación del ratón anterior (por ejemplo, sobrescribiendo mousePressEvent()) y acceptedMouseButtons() debe devolver el botón del ratón correspondiente.

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

[virtual protected] void QQuickItem::mouseUngrabEvent()

Este controlador de eventos se puede reimplementar en una subclase para recibir una notificación cuando se produzca un evento de liberación del ratón en este elemento.

[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, se trata del siguiente elemento en la dirección hacia delante. Si forward es false, se trata del siguiente elemento en la dirección hacia atrás.

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

void QQuickItem::polish()

Programa una acción de pulido para este elemento.

Cuando el grafo de escena procese la solicitud, llamará a updatePolish() sobre este elemento.

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

[virtual protected] void QQuickItem::releaseResources()

Esta función se invoca 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 representando anteriormente. Se garantiza que el elemento dispondrá de un ` window ` cuando se llame a la función.

La función se invoca en el hilo de la interfaz gráfica de usuario y se desconoce el estado del hilo de renderizado, en caso de que se utilice. Los objetos no deben eliminarse directamente, sino que debe programarse su limpieza mediante 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 tiene el foco en ese momento.

Devuelve « nullptr » si este elemento no es un ámbito de foco.

void QQuickItem::setAcceptHoverEvents(bool enabled)

Si enabled es verdadero, esta propiedad configura el elemento para que acepte eventos de desplazamiento del cursor; en caso contrario, este elemento no acepta dichos eventos.

Véase también acceptHoverEvents().

void QQuickItem::setAcceptTouchEvents(bool enabled)

Si « enabled » es verdadero, esta opción configura el elemento para que acepte eventos táctiles; de lo contrario, este elemento 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()` provocaba implícitamente que un elemento recibiera eventos táctiles además de eventos del ratón; sin embargo, 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 de « 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 secundarios de este elemento deben filtrarse a través de este.

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

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 «true»; si « enabled » es «false», el indicador queda desactivado.

Estas opciones proporcionan diversas indicaciones para el elemento; por ejemplo, la opción « ItemClipsChildrenToShape » indica que todos los elementos secundarios de este elemento deben recortarse para que quepan dentro del área del elemento.

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

Activa la opción « flags » especificada 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ónde asignación para la propiedad focusPolicy.

Véase también focusPolicy().

void QQuickItem::setKeepMouseGrab(bool keep)

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

Esto resulta útil para elementos que desean capturar y mantener la interacción del ratón tras un gesto predefinido. Por ejemplo, un elemento interesado en el movimiento horizontal del ratón puede establecer « keepMouseGrab » en «true» una vez 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 «false», un elemento de filtrado puede «robar» el control del ratón. Por ejemplo, Flickable puede intentar «robar» el control del ratón si detecta que el usuario ha comenzado a mover la ventana de visualización.

Véase también keepMouseGrab().

void QQuickItem::setKeepTouchGrab(bool keep)

Establece si los puntos táctiles capturados por este elemento deben permanecer exclusivamente asociados a él.

Esto resulta útil para elementos que desean capturar y conservar puntos táctiles específicos tras 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 en cuestión.

Si ` keep ` es `false`, un elemento de filtrado puede «robar» el control. Por ejemplo, ` Flickable ` puede intentar «robar» el control de un punto táctil si detecta que el usuario ha comenzado a mover la ventana de visualización.

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 enlace existente sobre el ancho y la altura; por lo tanto, cualquier cambio que provoque que el enlace 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 situado después del elemento hermano especificado dentro de la lista de elementos hijos. El orden de los elementos hijos afecta tanto al orden de apilamiento visual como al orden de navegación del foco de tabulación.

Suponiendo que los valores «z» de ambos elementos sean iguales, esto hará que sibling se muestre debajo de este elemento.

Si ambos elementos tienen ` activeFocusOnTab ` establecido en ` true`, esto también provocará que cambie el orden de enfoque del tabulador, de modo que ` sibling ` reciba el enfoque antes que este elemento.

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

Véase también Conceptos - Padre visual en Qt Quick.

void QQuickItem::stackBefore(const QQuickItem *sibling)

Mueve este elemento al índice anterior al elemento hermano especificado dentro de la lista de elementos hijos. El orden de los elementos hijos afecta tanto al orden de apilamiento visual como al orden de navegación del foco de tabulación.

Suponiendo que los valores z de ambos elementos sean iguales, esto hará que sibling se muestre por encima de este elemento.

Si ambos elementos tienen la propiedad « activeFocusOnTab » establecida en « true », esto también provocará que cambie el orden de enfoque del tabulador, de modo que « sibling » reciba el enfoque después de este elemento.

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

Véase también Conceptos - Padre visual en Qt Quick.

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

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

Esta función solo se puede invocar en el hilo de renderizado.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos táctiles de un elemento. La información del evento se proporciona a través del parámetro ` event `.

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

[virtual protected] void QQuickItem::touchUngrabEvent()

Este controlador de eventos se puede reimplementar en una subclase para recibir una notificación cuando se produzca un evento de liberación de toque en este elemento.

void QQuickItem::unsetCursor()

Borra la forma del cursor de 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 un ` QQuickWindow`.

Solo los elementos que especifiquen ` QQuickItem::ItemHasContents ` pueden llamar a `QQuickItem::update()`.

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

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

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

Se invoca en el hilo de renderizado cuando llega el momento de sincronizar el estado del elemento con el grafo de escena.

La función se invoca como resultado de ` QQuickItem::update()`, si el usuario ha activado el indicador « QQuickItem::ItemHasContents » en el elemento.

La función debe devolver la raíz del subárbol del grafo de escena correspondiente a este elemento. La mayoría de las implementaciones devolverán un único objeto ` QSGGeometryNode ` que contenga la representación visual de este elemento. ` oldNode ` es el nodo que se devolvió la última vez que se invocó la función. ` updatePaintNodeData ` proporciona un puntero a la ` QSGTransformNode ` asociada a 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 queda bloqueado mientras se ejecuta esta función, por lo que es seguro leer valores de la instancia QQuickItem y de otros objetos en el hilo principal.

Si ninguna llamada a QQuickItem::updatePaintNode() da lugar a cambios reales en el grafo de escena, como QSGNode::markDirty() o la adición y eliminación de nodos, la implementación subyacente puede decidir no volver a renderizar la escena, ya que el resultado visual es idéntico.

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

Advertencia: Esta función se invoca en el hilo de renderizado. Esto significa que cualquier QObject o almacenamiento local del hilo que se cree tendrá afinidad con el hilo de renderizado, por lo que hay que tener cuidado al realizar cualquier otra acción que no sea el renderizado en esta función. Del mismo modo, en el caso de las señales, estas se emitirán en el hilo de renderizado y, por lo tanto, a menudo se transmitirán a través de conexiones en cola.

Nota: Todas las clases con el prefijo «QSG» deben utilizarse exclusivamente en el hilo de renderizado del grafo de escena. Consulta «Grafo de escena y renderizado» para obtener 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 maquetación que sea necesaria para este elemento.

Cuando se llama a ` polish()`, el grafo de escena programa un evento «polish» para este elemento. Cuando el grafo de escena está listo para renderizar este elemento, llama a `updatePolish()` para realizar cualquier disposición del elemento que sea necesaria antes de renderizar el siguiente fotograma.

Véase también ensurePolished().

QQuickItem *QQuickItem::viewportItem() const

Si se ha activado el indicador « ItemObservesViewport », devuelve el elemento padre más cercano que tenga activado el indicador « ItemIsViewport ». Devuelve el «contentItem» de la ventana si el indicador no está activado o si no se encuentra ningún otro elemento de la ventana gráfica.

Devuelve ` nullptr ` solo si no hay ningún elemento de 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 controlador de eventos se puede reimplementar en una subclase para recibir eventos de rueda para un elemento. La información del evento se proporciona mediante el parámetro ` event `.

El evento se acepta de forma predeterminada, por lo que no es necesario aceptarlo explícitamente si se reimplementa esta función. Si no se 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 ventana hasta que se le haya asignado a una escena. La señal windowChanged() envía una notificación tanto cuando el elemento se introduce en una escena como cuando se elimina de ella.

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

Esta señal se emite cuando cambia el « window » del elemento.

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