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
slotdenominadoinvalidateSceneGraph(), 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, medianteEGL_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
nullo 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.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::ItemClipsChildrenToShape | 0x01 | Indica que este elemento debe recortar visualmente sus elementos secundarios para que se muestren únicamente dentro de los límites de este elemento. |
QQuickItem::ItemAcceptsInputMethod | 0x02 | Indica que el elemento admite métodos de entrada de texto. |
QQuickItem::ItemIsFocusScope | 0x04 | Indica que el elemento es un ámbito de foco. Para obtener más información, consulta «Foco del teclado» en Qt Quick. |
QQuickItem::ItemHasContents | 0x08 | Indica que el elemento tiene contenido visual y debe ser renderizado por el grafo de escena. |
QQuickItem::ItemAcceptsDrops | 0x10 | Indica que el elemento acepta eventos de arrastrar y soltar. |
QQuickItem::ItemIsViewport | 0x20 | Indica que el elemento define una ventana de visualización para sus elementos secundarios. |
QQuickItem::ItemObservesViewport | 0x40 | Indica 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.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::ItemChildAddedChange | 0 | Se ha añadido un elemento secundario. ItemChangeData::item contiene el elemento secundario añadido. |
QQuickItem::ItemChildRemovedChange | 1 | Se ha eliminado un elemento secundario. ItemChangeData::item contiene el elemento secundario eliminado. |
QQuickItem::ItemSceneChange | 2 | El 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::ItemVisibleHasChanged | 3 | La visibilidad del elemento ha cambiado. ItemChangeData::boolValue contiene la nueva visibilidad. |
QQuickItem::ItemParentHasChanged | 4 | El elemento padre del elemento ha cambiado. ItemChangeData::item contiene el nuevo elemento padre. |
QQuickItem::ItemOpacityHasChanged | 5 | La opacidad del elemento ha cambiado. ItemChangeData::realValue contiene la nueva opacidad. |
QQuickItem::ItemActiveFocusHasChanged | 6 | El foco del elemento ha cambiado. ItemChangeData::boolValue indica si el elemento tiene el foco o no. |
QQuickItem::ItemRotationHasChanged | 7 | La rotación del elemento ha cambiado. ` ItemChangeData::realValue ` contiene la nueva rotación. |
QQuickItem::ItemDevicePixelRatioHasChanged | 9 | La 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::ItemAntialiasingHasChanged | 8 | El suavizado se ha modificado. El valor actual (booleano) se puede encontrar en ` QQuickItem::antialiasing`. |
QQuickItem::ItemEnabledHasChanged | 10 | El estado de activación del elemento ha cambiado. ItemChangeData::boolValue contiene el nuevo estado de activación. (desde Qt 5.10) |
QQuickItem::ItemScaleHasChanged | 11 | La escala del elemento ha cambiado. ItemChangeData::realValue contiene la escala. (desde Qt 6.9) |
QQuickItem::ItemTransformHasChanged | 12 | La 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 ».
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::AutoMutabilityGroup | 0x0 | El grupo de mutabilidad predeterminado. |
QQuickItem::StaticMutabilityGroup | 0x1 | Indica que el elemento se actualiza muy raramente o nunca. |
QQuickItem::ModerateMutabilityGroup | 0x8 | Indica que el elemento se actualiza con una frecuencia moderada. |
QQuickItem::DynamicMutabilityGroup | 0xf | Indica 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.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::TopLeft | 0 | La esquina superior izquierda del elemento. |
QQuickItem::Top | 1 | El punto central de la parte superior del elemento. |
QQuickItem::TopRight | 2 | La esquina superior derecha del elemento. |
QQuickItem::Left | 3 | El punto más a la izquierda de la línea central vertical. |
QQuickItem::Center | 4 | El centro del elemento. |
QQuickItem::Right | 5 | El punto más a la derecha de la línea central vertical. |
QQuickItem::BottomLeft | 6 | La esquina inferior izquierda del elemento. |
QQuickItem::Bottom | 7 | El punto central de la parte inferior del elemento. |
QQuickItem::BottomRight | 8 | La 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.
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() |
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.
| |
|
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).
|
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`.
|
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.

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.
| Mismo « z »: los hijos posteriores aparecen encima de los anteriores:
|
| z o más alto en la parte superior:
|
| Mismo « z » — los hijos por encima de los padres:
|
| z inferior, abajo:
|
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.







