QQuickItem Class
La clase QQuickItem proporciona el más básico de todos los elementos visuales en Qt Quick. Más...
| Cabecera: | #include <QQuickItem> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Quick)target_link_libraries(mytarget PRIVATE Qt6::Quick) |
| qmake: | QT += quick |
| En QML: | Item |
| Hereda: | QObject y QQmlParserStatus |
| Heredado de: |
Tipos públicos
| union | ItemChangeData |
| enum | Flag { ItemClipsChildrenToShape, ItemAcceptsInputMethod, ItemIsFocusScope, ItemHasContents, ItemAcceptsDrops, …, ItemObservesViewport } |
| flags | Flags |
| enum | ItemChange { ItemChildAddedChange, ItemChildRemovedChange, ItemSceneChange, ItemVisibleHasChanged, ItemParentHasChanged, …, ItemTransformHasChanged } |
| enum | TransformOrigin { TopLeft, Top, TopRight, Left, Center, …, BottomRight } |
Propiedades
|
Funciones públicas
| QQuickItem(QQuickItem *parent = nullptr) | |
| virtual | ~QQuickItem() override |
| bool | acceptHoverEvents() const |
| bool | acceptTouchEvents() const |
| Qt::MouseButtons | acceptedMouseButtons() const |
| bool | activeFocusOnTab() const |
| bool | antialiasing() const |
| qreal | baselineOffset() const |
| QBindable<qreal> | bindableHeight() |
| QBindable<qreal> | bindableWidth() |
| QBindable<qreal> | bindableX() |
| QBindable<qreal> | bindableY() |
| virtual QRectF | boundingRect() const |
| QQuickItem * | childAt(qreal x, qreal y) const |
| QList<QQuickItem *> | childItems() const |
| QRectF | childrenRect() |
| bool | clip() const |
| virtual QRectF | clipRect() const |
| QObject * | containmentMask() const |
| virtual bool | contains(const QPointF &point) const |
| QCursor | cursor() const |
(since 6.3) void | dumpItemTree() const |
(since 6.3) void | ensurePolished() |
| bool | filtersChildMouseEvents() const |
| QQuickItem::Flags | flags() const |
| Qt::FocusPolicy | focusPolicy() const |
| void | forceActiveFocus() |
| void | forceActiveFocus(Qt::FocusReason reason) |
| QSharedPointer<QQuickItemGrabResult> | grabToImage(const QSize &targetSize = QSize()) |
| bool | hasActiveFocus() const |
| bool | hasFocus() const |
| qreal | height() const |
| qreal | implicitHeight() const |
| qreal | implicitWidth() const |
| virtual QVariant | inputMethodQuery(Qt::InputMethodQuery query) const |
| bool | isAncestorOf(const QQuickItem *child) const |
| bool | isEnabled() const |
| bool | isFocusScope() const |
| virtual bool | isTextureProvider() const |
| bool | isVisible() const |
| bool | keepMouseGrab() const |
| bool | keepTouchGrab() const |
| QPointF | mapFromGlobal(const QPointF &point) const |
| QPointF | mapFromItem(const QQuickItem *item, const QPointF &point) const |
| QPointF | mapFromScene(const QPointF &point) const |
| QRectF | mapRectFromItem(const QQuickItem *item, const QRectF &rect) const |
| QRectF | mapRectFromScene(const QRectF &rect) const |
| QRectF | mapRectToItem(const QQuickItem *item, const QRectF &rect) const |
| QRectF | mapRectToScene(const QRectF &rect) const |
| QPointF | mapToGlobal(const QPointF &point) const |
| QPointF | mapToItem(const QQuickItem *item, const QPointF &point) const |
| QPointF | mapToScene(const QPointF &point) const |
| QQuickItem * | nextItemInFocusChain(bool forward = true) |
| qreal | opacity() const |
| QQuickItem * | parentItem() const |
| void | polish() |
| void | resetAntialiasing() |
| void | resetHeight() |
| void | resetWidth() |
| qreal | rotation() const |
| qreal | scale() const |
| QQuickItem * | scopedFocusItem() const |
| void | setAcceptHoverEvents(bool enabled) |
| void | setAcceptTouchEvents(bool enabled) |
| void | setAcceptedMouseButtons(Qt::MouseButtons buttons) |
| void | setActiveFocusOnTab(bool) |
| void | setAntialiasing(bool) |
| void | setBaselineOffset(qreal) |
| void | setClip(bool) |
| void | setContainmentMask(QObject *mask) |
| void | setCursor(const QCursor &cursor) |
| void | setEnabled(bool) |
| void | setFiltersChildMouseEvents(bool filter) |
| void | setFlag(QQuickItem::Flag flag, bool enabled = true) |
| void | setFlags(QQuickItem::Flags flags) |
| void | setFocus(bool) |
| void | setFocus(bool focus, Qt::FocusReason reason) |
| void | setFocusPolicy(Qt::FocusPolicy policy) |
| void | setHeight(qreal) |
| void | setImplicitHeight(qreal) |
| void | setImplicitWidth(qreal) |
| void | setKeepMouseGrab(bool keep) |
| void | setKeepTouchGrab(bool keep) |
| void | setOpacity(qreal) |
| void | setParentItem(QQuickItem *parent) |
| void | setRotation(qreal) |
| void | setScale(qreal) |
| void | setSize(const QSizeF &size) |
| void | setSmooth(bool) |
| void | setState(const QString &) |
| void | setTransformOrigin(QQuickItem::TransformOrigin) |
| void | setVisible(bool) |
| void | setWidth(qreal) |
| void | setX(qreal) |
| void | setY(qreal) |
| void | setZ(qreal) |
| QSizeF | size() const |
| bool | smooth() const |
| void | stackAfter(const QQuickItem *sibling) |
| void | stackBefore(const QQuickItem *sibling) |
| QString | state() const |
| virtual QSGTextureProvider * | textureProvider() const |
| QQuickItem::TransformOrigin | transformOrigin() const |
| void | unsetCursor() |
| QQuickItem * | viewportItem() const |
| qreal | width() const |
| QQuickWindow * | window() const |
| qreal | x() const |
| qreal | y() const |
| qreal | z() const |
Ranuras públicas
| void | update() |
Señales
| void | activeFocusChanged(bool) |
| void | activeFocusOnTabChanged(bool) |
| void | antialiasingChanged(bool) |
| void | baselineOffsetChanged(qreal) |
| void | childrenRectChanged(const QRectF &) |
| void | clipChanged(bool) |
| void | containmentMaskChanged() |
| void | enabledChanged() |
| void | focusChanged(bool) |
| void | focusPolicyChanged(Qt::FocusPolicy) |
| void | heightChanged() |
| void | implicitHeightChanged() |
| void | implicitWidthChanged() |
| void | opacityChanged() |
| void | parentChanged(QQuickItem *) |
| void | rotationChanged() |
| void | scaleChanged() |
| void | smoothChanged(bool) |
| void | stateChanged(const QString &) |
| void | transformOriginChanged(QQuickItem::TransformOrigin) |
| void | visibleChanged() |
| void | widthChanged() |
| void | windowChanged(QQuickWindow *window) |
| void | xChanged() |
| void | yChanged() |
| void | zChanged() |
Funciones protegidas
| bool virtual | childMouseEventFilter(QQuickItem *item, QEvent *event) |
| virtual void | dragEnterEvent(QDragEnterEvent *event) |
| virtual void | dragLeaveEvent(QDragLeaveEvent *event) |
| virtual void | dragMoveEvent(QDragMoveEvent *event) |
| virtual void | dropEvent(QDropEvent *event) |
| virtual void | focusInEvent(QFocusEvent *event) |
| virtual void | focusOutEvent(QFocusEvent *event) |
(since 6.0) virtual void | geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry) |
| bool | heightValid() const |
| void virtual | hoverEnterEvent(QHoverEvent *event) |
| virtual void | hoverLeaveEvent(QHoverEvent *event) |
| virtual void | hoverMoveEvent(QHoverEvent *event) |
| virtual void | inputMethodEvent(QInputMethodEvent *event) |
| bool | isComponentComplete() const |
| virtual void | itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value) |
| virtual void | keyPressEvent(QKeyEvent *event) |
| virtual void | keyReleaseEvent(QKeyEvent *event) |
| virtual void | mouseDoubleClickEvent(QMouseEvent *event) |
| virtual void | mouseMoveEvent(QMouseEvent *event) |
| virtual void | mousePressEvent(QMouseEvent *event) |
| virtual void | mouseReleaseEvent(QMouseEvent *event) |
| virtual void | mouseUngrabEvent() |
| virtual void | releaseResources() |
| virtual void | touchEvent(QTouchEvent *event) |
| virtual void | touchUngrabEvent() |
| void | updateInputMethod(Qt::InputMethodQueries queries = Qt::ImQueryInput) |
| virtual QSGNode * | updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *updatePaintNodeData) |
| virtual void | updatePolish() |
| virtual void | wheelEvent(QWheelEvent *event) |
| bool | widthValid() const |
Funciones protegidas reimplementadas
| virtual void | classBegin() override |
| virtual void | componentComplete() override |
| virtual bool | event(QEvent *ev) override |
Descripción Detallada
Todos los elementos visuales de Qt Quick heredan de QQuickItem. Aunque una instancia de QQuickItem no tiene apariencia visual, define todos los atributos que son comunes a los ítems visuales, como la posición x e y, anchura y altura, anclaje y soporte de manejo de teclas.
Puede subclasificar QQuickItem para proporcionar su propio elemento visual personalizado que herede estas características.
Elementos gráficos de escena personalizados
Todos los elementos visuales QML se renderizan utilizando el gráfico de escena, cuya implementación predeterminada es una pila de renderizado de alto rendimiento y bajo nivel, estrechamente vinculada a API de gráficos acelerados, como OpenGL, Vulkan, Metal o Direct 3D. Es posible para las subclases de QQuickItem añadir su propio contenido personalizado en el gráfico de escena estableciendo la bandera QQuickItem::ItemHasContents y reimplementando la función QQuickItem::updatePaintNode().
Advertencia: Es crucial que las operaciones gráficas y la interacción con el gráfico de escena ocurran exclusivamente en el hilo de renderizado, principalmente durante la llamada a updatePaintNode(). La mejor regla general es utilizar únicamente clases con el prefijo "QSG" dentro de la función QQuickItem::updatePaintNode().
Nota: Todas las clases con el prefijo QSG deben utilizarse únicamente en el subproceso de renderizado del gráfico de escena. Ver Gráfico de Escena y Renderizado para más información.
Gestión de recursos gráficos
La forma preferida de manejar la limpieza de los recursos gráficos utilizados en el gráfico de escena, es confiar en la limpieza automática de los nodos. Un QSGNode devuelto desde QQuickItem::updatePaintNode() se borra automáticamente en el hilo adecuado en el momento adecuado. Los árboles de instancias QSGNode se gestionan mediante el uso de QSGNode::OwnedByParent, que se establece por defecto. Por lo tanto, para la mayoría de los elementos gráficos de escena personalizados, no será necesario ningún trabajo adicional.
Las implementaciones que almacenan recursos gráficos fuera del árbol de nodos, como un elemento que implemente QQuickItem::textureProvider(), tendrán que tener cuidado a la hora de limpiarlo correctamente dependiendo de cómo se utilice el elemento en QML. Las situaciones a manejar son:
- El gráfico de escena se invalida; Esto puede ocurrir, dependiendo de la plataforma y de la configuración de QQuickWindow, cuando la ventana se oculta usando QQuickWindow::hide(), o cuando se cierra. Si la clase item implementa un
slotllamadoinvalidateSceneGraph(), este slot será llamado en el hilo de renderizado mientras el hilo GUI está bloqueado. Esto es equivalente a conectarse a QQuickWindow::sceneGraphInvalidated(). Cuando se renderiza a través de OpenGL, el contexto OpenGL de la ventana de este elemento se vinculará cuando se llame a esta ranura. La única excepción es si el OpenGL nativo ha sido destruido fuera del control de Qt, por ejemplo a través deEGL_CONTEXT_LOST. - El ítem es removido de la escena; Si un ítem es removido de la escena, por ejemplo porque su padre fue puesto en
nullo un ítem en otra ventana, el QQuickItem::releaseResources() será llamado en el hilo GUI. QQuickWindow::scheduleRenderJob() debe utilizarse para programar la limpieza de los recursos de renderizado. - El ítem es borrado; Cuando el destructor de un ítem se ejecuta, debería borrar cualquier recurso gráfico que tenga. Si no se cumple ninguna de las dos condiciones anteriores, el elemento formará parte de una ventana y es posible utilizar QQuickWindow::scheduleRenderJob() para que se limpien. Si una implementación ignora la llamada a QQuickItem::releaseResources(), en muchos casos el elemento ya no tendrá acceso a QQuickWindow y, por tanto, no podrá programar la limpieza.
Al programar la limpieza de los recursos gráficos mediante QQuickWindow::scheduleRenderJob(), se debe utilizar QQuickWindow::BeforeSynchronizingStage o QQuickWindow::AfterSynchronizingStage. La etapa de sincronización es en la que se modifica el gráfico de la escena como resultado de los cambios en el árbol QML. Si la limpieza se programa en cualquier otro momento, es posible que otras partes del gráfico de escena hagan referencia a los objetos recién eliminados, ya que estas partes no se han actualizado.
Nota: Se desaconseja encarecidamente el uso de QObject::deleteLater() para limpiar los recursos gráficos, ya que esto hará que la operación delete se ejecute en un momento arbitrario y se desconoce si habrá un contexto OpenGL vinculado cuando se produzca la eliminación.
Elementos personalizados de QPainter
El QQuickItem proporciona una subclase, QQuickPaintedItem, que permite a los usuarios renderizar contenido utilizando QPainter.
Advertencia: El uso de QQuickPaintedItem utiliza una superficie 2D indirecta para renderizar su contenido, utilizando rasterización por software, por lo que el renderizado es una operación de dos pasos. Primero se rasteriza la superficie y luego se dibuja la superficie. Usar directamente la API de scene graph es siempre significativamente más rápido.
Animaciones de comportamiento
Si tu Item utiliza el tipo Behavior para definir animaciones para cambios de propiedades, deberías utilizar siempre QObject::setProperty(), QQmlProperty(), o QMetaProperty::write() cuando necesites modificar esas propiedades desde C++. Esto garantiza que el motor QML conozca el cambio de propiedad. De lo contrario, el motor no podrá llevar a cabo la animación solicitada. Tenga en cuenta que estas funciones conllevan una ligera penalización de rendimiento. Para obtener más información, consulte Acceso a los miembros de un tipo de objeto QML desde C++.
Véase también QQuickWindow y QQuickPaintedItem.
Documentación de tipos de miembros
enum QQuickItem::Bandera
banderas QQuickItem::Banderas
Este tipo enum se utiliza para especificar varias propiedades de los elementos.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::ItemClipsChildrenToShape | 0x01 | Indica que este ítem debe recortar visualmente a sus hijos para que se muestren sólo dentro de los límites de este ítem. |
QQuickItem::ItemAcceptsInputMethod | 0x02 | Indica que el elemento soporta métodos de entrada de texto. |
QQuickItem::ItemIsFocusScope | 0x04 | Indica que el elemento es un ámbito de enfoque. Consulte Enfoque de teclado en Qt Quick para obtener más información. |
QQuickItem::ItemHasContents | 0x08 | Indica que el elemento tiene contenido visual y debe ser representado por el gráfico 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 gráfica para sus hijos. |
QQuickItem::ItemObservesViewport | 0x40 | Indica que el ítem desea conocer los límites de la ventana gráfica cuando algún ancestro tiene activado el indicador ItemIsViewport. |
El tipo Flags es un typedef para QFlags<Flag>. Almacena una combinación OR de valores Flag.
Véase también setFlag(), setFlags(), y flags().
enum QQuickItem::ItemChange
Se utiliza junto con QQuickItem::itemChange() para notificar al elemento ciertos tipos de cambios.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::ItemChildAddedChange | 0 | Se ha añadido un hijo. ItemChangeData::item contiene el hijo añadido. |
QQuickItem::ItemChildRemovedChange | 1 | Se ha eliminado un hijo. ItemChangeData::item contiene el hijo eliminado. |
QQuickItem::ItemSceneChange | 2 | El elemento se ha añadido o eliminado de una escena. La representación de la escena en QQuickWindow se especifica en ItemChangeData::window. El parámetro de ventana es nulo cuando el elemento se elimina de una escena. |
QQuickItem::ItemVisibleHasChanged | 3 | La visibilidad del elemento ha cambiado. ItemChangeData::boolValue contiene la nueva visibilidad. |
QQuickItem::ItemParentHasChanged | 4 | El padre del elemento ha cambiado. ItemChangeData::item contiene el nuevo 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 contiene si el elemento tiene foco o no. |
QQuickItem::ItemRotationHasChanged | 7 | La rotación del elemento ha cambiado. ItemChangeData::realValue contiene la nueva rotación. |
QQuickItem::ItemDevicePixelRatioHasChanged | 9 | La proporción de píxeles del dispositivo de la pantalla en la que se encuentra el elemento ha cambiado. ItemChangedData::realValue contiene la nueva relación de píxeles del dispositivo. |
QQuickItem::ItemAntialiasingHasChanged | 8 | El antialiasing ha cambiado. El valor actual (booleano) se encuentra en QQuickItem::antialiasing. |
QQuickItem::ItemEnabledHasChanged | 10 | El estado activado del elemento ha cambiado. ItemChangeData::boolValue contiene el nuevo estado activado. (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 la posición, el tamaño, la rotación, la escala, transformOrigin o las transformaciones adjuntas del elemento cambian. ItemChangeData::item contiene el elemento que causó el cambio. (desde Qt 6.9) |
enum QQuickItem::TransformOrigin
Controla el punto sobre el que se aplican transformaciones simples como la escala.
| Constante | Valor | Descripción |
|---|---|---|
QQuickItem::TopLeft | 0 | La esquina superior izquierda del elemento. |
QQuickItem::Top | 1 | El punto central de la parte superior del ítem. |
QQuickItem::TopRight | 2 | La esquina superior derecha del elemento. |
QQuickItem::Left | 3 | El punto más a la izquierda del centro vertical. |
QQuickItem::Center | 4 | El centro del elemento. |
QQuickItem::Right | 5 | El punto más a la derecha del centro 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 sólo lectura indica si el elemento tiene el foco activo.
Si activeFocus es verdadero, este elemento es el que actualmente recibe la entrada del teclado, o es un FocusScope ancestro del elemento que actualmente recibe la entrada del teclado.
Normalmente, activeFocus se obtiene estableciendo focus en un elemento y en los objetos FocusScope que lo rodean. En el siguiente ejemplo, los objetos input y focusScope tendrán el foco activo, mientras que el objeto rectángulo raíz no lo tendrá.
import QtQuick 2.0 Rectangle { width: 100; height: 100 FocusScope { focus: true TextInput { id: input focus: true } } }
Funciones de acceso:
| bool | hasActiveFocus() const |
Señal del notificador:
| void | activeFocusChanged(bool) |
Véase también focus y Enfoque del teclado en Qt Quick.
activeFocusOnTab : bool
Esta propiedad indica si el elemento quiere estar en la cadena de enfoque de la pestaña. Por defecto, se establece en false.
Nota: tabFocusBehavior puede limitar aún más el foco a sólo tipos específicos de controles, como sólo controles de texto o de lista. Este es el caso de macOS, donde el foco de determinados controles puede estar restringido en función de la configuración del sistema.
Funciones de acceso:
| bool | activeFocusOnTab() const |
| void | setActiveFocusOnTab(bool) |
Señal del notificador:
| void | activeFocusOnTabChanged(bool) |
Véase también QStyleHints::tabFocusBehavior y focusPolicy.
antialiasing : bool
Especifica si el elemento tiene antialiasing o no.
Utilizado por los elementos visuales para decidir si el elemento debe utilizar antialiasing o no. En algunos casos los elementos con antialiasing requieren más memoria y son potencialmente más lentos de renderizar (ver Antialiasing para más detalles).
Por defecto es false, pero puede ser sobreescrito por elementos derivados.
Funciones de acceso:
| bool | antialiasing() const |
| void | setAntialiasing(bool) |
| void | resetAntialiasing() |
Señal de notificador:
| void | antialiasingChanged(bool) |
baselineOffset : qreal
Especifica la posición de la línea de base del elemento en coordenadas locales.
La línea de base de un elemento Text es la línea imaginaria sobre la que se sitúa el texto. Los controles que contienen texto suelen fijar su línea de base en la línea de base de su texto.
Para los elementos que no contienen texto, se utiliza una línea de base por defecto de 0.
Funciones de acceso:
| qreal | baselineOffset() const |
| void | setBaselineOffset(qreal) |
Señal del notificador:
| void | baselineOffsetChanged(qreal) |
[read-only] childrenRect : QRectF
Esta propiedad contiene la posición colectiva y el tamaño de los elementos hijos.
Esta propiedad es útil si necesitas acceder a la geometría colectiva de los hijos de un elemento para dimensionar correctamente el elemento.
La geometría que se devuelve es local al elemento. Por ejemplo:
Item { x: 50 y: 100 // prints: QRectF(-10, -20, 30, 40) Component.onCompleted: print(childrenRect) Item { x: -10 y: -20 width: 30 height: 40 } }
Funciones de acceso:
| QRectF | childrenRect() |
Señal del notificador:
| void | childrenRectChanged(const QRectF &) |
clip : bool
Esta propiedad indica si el recorte está activado. El valor de recorte por defecto es false.
Si el recorte está habilitado, un elemento recortará su propia pintura, así como la pintura de sus hijos, a su rectángulo delimitador. Si activas el recorte durante la operación de pintado de un elemento, recuerda volver a activarlo para evitar que se recorte el resto de la escena.
Nota: El recorte puede afectar al rendimiento del renderizado. Consulte Recorte para obtener más información.
Nota: Por el bien de QML, establecer clip a true también establece la bandera ItemIsViewport, que a veces actúa como una optimización: los elementos hijos que tienen la bandera ItemObservesViewport pueden renunciar a crear nodos del gráfico de escena que caen fuera de la ventana gráfica. Sin embargo, el indicador ItemIsViewport también puede establecerse de forma independiente.
Funciones de acceso:
| bool | clip() const |
| void | setClip(bool) |
Señal de notificación:
| void | clipChanged(bool) |
containmentMask : QObject*
Esta propiedad contiene una máscara opcional que se utilizará en el método contains(), que se utiliza principalmente para probar cada QPointerEvent.
Por defecto, contains() devolverá true para cualquier punto dentro del cuadro delimitador del elemento. Pero cualquier QQuickItem, o cualquier QObject que implemente una función de la forma
Q_INVOKABLE bool contains(const QPointF &point) const;
puede utilizarse como máscara, para diferir la prueba de acierto a ese objeto.
Nota: contains() se llama frecuentemente durante la entrega de eventos. Diferir la prueba de impacto a otro objeto la ralentiza un poco. containmentMask() puede causar problemas de rendimiento si el método contains() de ese objeto no es eficiente. Si implementas una subclase personalizada de QQuickItem, puedes alternativamente anular contains().
Funciones de acceso:
| QObject * | containmentMask() const |
| void | setContainmentMask(QObject *mask) |
Señal de notificador:
| void | containmentMaskChanged() |
Véase también contains().
enabled : bool
Esta propiedad indica si el elemento recibe eventos de ratón y teclado. Por defecto es true.
Establecer esta propiedad afecta directamente al valor enabled de los ítems hijos. Cuando se establece a false, los valores de enabled de todos los ítems hijos también se convierten en false. Cuando se establece a true, los valores enabled de los ítems hijos vuelven a true, a menos que hayan sido explícitamente establecidos a false.
Si se establece esta propiedad en false, activeFocus se convierte automáticamente en false, y este elemento dejará de recibir eventos de teclado.
Nota: Los eventos Hover se activan por separado mediante setAcceptHoverEvents(). Así, un elemento deshabilitado puede seguir recibiendo eventos hover, incluso cuando esta propiedad es false. Esto hace posible mostrar información (como ToolTip) incluso cuando un elemento interactivo está deshabilitado. Lo mismo ocurre con cualquier HoverHandlers añadido como hijo del elemento. Un HoverHandler puede, sin embargo, ser disabled explícitamente, o por ejemplo estar ligado al estado enabled del elemento.
Funciones de acceso:
| bool | isEnabled() const |
| void | setEnabled(bool) |
Señal de notificación:
| void | enabledChanged() |
Véase también visible.
focus : bool
Esta propiedad indica si el elemento tiene foco dentro del elemento adyacente FocusScope. Si es verdadero, este elemento obtendrá el foco activo cuando el elemento FocusScope adquiera el foco activo.
En el siguiente ejemplo, input tendrá foco activo cuando scope tenga foco activo:
import QtQuick 2.0 Rectangle { width: 100; height: 100 FocusScope { id: scope TextInput { id: input focus: true } } }
A efectos de esta propiedad, se supone que la escena en su conjunto actúa como un ámbito de foco. A nivel práctico, esto significa que el siguiente QML dará foco activo a input al iniciarse.
Funciones de acceso:
| bool | hasFocus() const |
| void | setFocus(bool) |
| void | setFocus(bool focus, Qt::FocusReason reason) |
Señal de notificador:
| void | focusChanged(bool) |
Véase también activeFocus y Keyboard Focus en Qt Quick.
[since 6.7] focusPolicy : Qt::FocusPolicy
Esta propiedad determina la forma en que el elemento acepta el foco.
Esta propiedad se introdujo en Qt 6.7.
Funciones de acceso:
| Qt::FocusPolicy | focusPolicy() const |
| void | setFocusPolicy(Qt::FocusPolicy policy) |
Señal del notificador:
| void | focusPolicyChanged(Qt::FocusPolicy) |
[bindable] height : qreal
Nota: Esta propiedad es compatible con QProperty.
Esta propiedad contiene la altura de este elemento.
Funciones de acceso:
| qreal | height() const |
| void | setHeight(qreal) |
| void | resetHeight() |
Señal del notificador:
| void | heightChanged() |
Define la anchura o altura preferida del elemento.
Si no se especifica width o height, el tamaño efectivo de un elemento vendrá determinado por su implicitWidth o implicitHeight.
Sin embargo, si un elemento es hijo de un diseño, el diseño determinará el tamaño preferido del elemento utilizando su tamaño implícito. En este caso, se ignorará el tamaño explícito de width o height.
El tamaño implícito por defecto para la mayoría de los elementos es 0x0, sin embargo algunos elementos tienen un tamaño implícito inherente que no puede ser anulado, por ejemplo, Image y Text.
Establecer el tamaño implícito es útil para definir componentes que tienen un tamaño preferido basado en su contenido, por ejemplo:
// Label.qml import QtQuick 2.0 Item { property alias icon: image.source property alias label: text.text implicitWidth: text.implicitWidth + image.implicitWidth implicitHeight: Math.max(text.implicitHeight, image.implicitHeight) Image { id: image } Text { id: text wrapMode: Text.Wrap anchors.left: image.right; anchors.right: parent.right anchors.verticalCenter: parent.verticalCenter } }
Nota: Si se utiliza implicitWidth de Text o TextEdit y se define explícitamente la anchura, el rendimiento se verá afectado, ya que el texto deberá presentarse dos veces.
opacity : qreal
Esta propiedad contiene la opacidad del elemento. La opacidad se especifica como un número entre 0.0 (totalmente transparente) y 1.0 (totalmente opaco). El valor por defecto es 1.0.
Cuando se establece esta propiedad, la opacidad especificada también se aplica individualmente a los elementos hijos. Esto puede tener un efecto no deseado en algunas circunstancias. Por ejemplo, en el segundo conjunto de rectángulos de abajo, el rectángulo rojo ha especificado una opacidad de 0,5, que afecta a la opacidad de su rectángulo azul hijo, aunque el hijo no haya especificado una opacidad.
Los valores fuera del rango de 0 a 1 serán fijados.
| |
|
Cambiar la opacidad de un elemento no afecta a si el elemento recibe eventos de entrada del usuario. (Por el contrario, establecer la propiedad visible a false detiene los eventos de ratón, y establecer la propiedad enabled a false detiene los eventos de ratón y teclado, y también elimina el foco activo del elemento).
Funciones de acceso:
| qreal | opacity() const |
| void | setOpacity(qreal) |
Señal de notificador:
| void | opacityChanged() |
Véase también visible.
parent : QQuickItem*
Esta propiedad contiene el padre visual del elemento.
Nota: El concepto de padre visual difiere del de padreQObject . El padre visual de un ítem puede no ser necesariamente el mismo que su objeto padre. Ver Conceptos - Padre visual en Qt Quick para más detalles.
Nota: La señal de notificación para esta propiedad se emite durante la destrucción del padre visual. Los manejadores de señales C++ no pueden asumir que los elementos en la jerarquía visual padre están todavía completamente construidos. Utilice qobject_cast para verificar que los elementos de la jerarquía padre pueden utilizarse de forma segura como el tipo esperado.
Funciones de acceso:
| QQuickItem * | parentItem() const |
| void | setParentItem(QQuickItem *parent) |
Señal de notificador:
| void | parentChanged(QQuickItem *) |
rotation : qreal
Esta propiedad contiene la rotación del elemento en grados en el sentido de las agujas del reloj alrededor de su transformOrigin.
El valor por defecto es 0 grados (es decir, sin rotación).
|
Funciones de acceso:
| qreal | rotation() const |
| void | setRotation(qreal) |
Señal del notificador:
| void | rotationChanged() |
Véase también Transform y Rotation.
scale : qreal
Esta propiedad contiene el factor de escala para este elemento.
Una escala inferior a 1,0 hace que el elemento se muestre a un tamaño menor, y una escala superior a 1,0 hace que el elemento se muestre a un tamaño mayor. Una escala negativa hace que el elemento se refleje al renderizarlo.
El valor por defecto es 1.0.
La escala se aplica desde transformOrigin.
|
Funciones de acceso:
| qreal | scale() const |
| void | setScale(qreal) |
Señal notificadora:
| void | scaleChanged() |
Véase también Transform y Scale.
smooth : bool
Especifica si el elemento está suavizado o no.
Se utiliza principalmente en elementos basados en imágenes para decidir si el elemento debe utilizar un muestreo suave o no. El muestreo suavizado se realiza mediante interpolación lineal, mientras que el no suavizado se realiza mediante el vecino más próximo.
En Qt Quick 2.0, esta propiedad tiene un impacto mínimo en el rendimiento.
Por defecto, esta propiedad se establece en true.
Funciones de acceso:
| bool | smooth() const |
| void | setSmooth(bool) |
Señal del notificador:
| void | smoothChanged(bool) |
state : QString
Esta propiedad contiene el nombre del estado actual del elemento.
Si el elemento está en su estado por defecto, es decir, no se ha establecido ningún estado explícito, esta propiedad contendrá una cadena vacía. Del mismo modo, puede devolver un elemento a su estado por defecto estableciendo esta propiedad a una cadena vacía.
Funciones de acceso:
| QString | state() const |
| void | setState(const QString &) |
Señal del notificador:
| void | stateChanged(const QString &) |
Véase también Qt Quick Estados.
transformOrigin : TransformOrigin
Esta propiedad contiene el punto de origen alrededor del cual se transforman la escala y la rotación.
Hay nueve orígenes de transformación disponibles, como se muestra en la siguiente imagen. El origen de transformación por defecto es Item.Center.

Funciones de acceso:
| QQuickItem::TransformOrigin | transformOrigin() const |
| void | setTransformOrigin(QQuickItem::TransformOrigin) |
Señal de notificador:
| void | transformOriginChanged(QQuickItem::TransformOrigin) |
visible : bool
Esta propiedad indica si el elemento es visible. Por defecto es true.
Establecer esta propiedad afecta directamente al valor visible de los elementos hijos. Cuando se establece a false, los valores de visible de todos los elementos hijos también se convierten en false. Cuando se establece a true, los valores de visible de los elementos hijos vuelven a true, a menos que se hayan establecido explícitamente a false.
(Debido a este comportamiento, el uso de la propiedad visible puede no tener el efecto deseado si un enlace de propiedad sólo debe responder a cambios explícitos de propiedad. En tales casos, puede ser mejor utilizar la propiedad opacity en su lugar).
Si esta propiedad se establece en false, el elemento dejará de recibir eventos de ratón, pero seguirá recibiendo eventos de teclado y conservará el teclado focus si se ha establecido. (Por el contrario, establecer la propiedad enabled a false detiene tanto los eventos de ratón como de teclado, y también elimina el foco del elemento).
Nota: El valor de esta propiedad sólo se ve afectado por cambios en esta propiedad o en la propiedad visible del elemento padre. No cambia, por ejemplo, si este ítem se mueve fuera de la pantalla, o si el opacity cambia a 0. Sin embargo, por razones históricas, esta propiedad es verdadera después de la construcción del ítem, incluso si el ítem no ha sido añadido a una escena todavía. Cambiar o leer esta propiedad de un ítem que no ha sido añadido a una escena podría no producir los resultados esperados.
Nota: La señal de notificación de esta propiedad se emite durante la destrucción del elemento visual padre. Los manejadores de señales C++ no pueden asumir que los elementos en la jerarquía visual padre están todavía completamente construidos. Utilice qobject_cast para verificar que los elementos de la jerarquía padre pueden utilizarse de forma segura como el tipo esperado.
Funciones de acceso:
| bool | isVisible() const |
| void | setVisible(bool) |
Señal de notificador:
| void | visibleChanged() |
Véase también opacity y enabled.
[bindable] width : qreal
Nota: Esta propiedad es compatible con QProperty.
Esta propiedad contiene el ancho de este elemento.
Funciones de acceso:
| qreal | width() const |
| void | setWidth(qreal) |
| void | resetWidth() |
Señal del notificador:
| void | widthChanged() |
[bindable] x : qreal
Nota: Esta propiedad es compatible con QProperty.
Define la posición x del elemento respecto a su padre.
Funciones de acceso:
| qreal | x() const |
| void | setX(qreal) |
Señal del notificador:
| void | xChanged() |
[bindable] y : qreal
Nota: Esta propiedad es compatible con QProperty.
Define la posición y del elemento respecto a su padre.
Funciones de acceso:
| qreal | y() const |
| void | setY(qreal) |
Señal del notificador:
| void | yChanged() |
z : qreal
Establece el orden de apilamiento de los elementos hermanos. Por defecto, el orden de apilamiento es 0.
Los elementos con un valor de apilamiento mayor se dibujan encima de sus hermanos con un orden de apilamiento menor. Los elementos con el mismo valor de apilamiento se dibujan de abajo hacia arriba en el orden en que aparecen. Los elementos con un valor de apilamiento negativo se dibujan debajo del contenido de su padre.
El siguiente ejemplo muestra los distintos efectos del orden de apilamiento.
| Mismo z - los elementos posteriores están por encima de los anteriores:
|
| Más arriba z:
|
| Mismo z - hijos por encima de padres:
|
| Más bajo z abajo:
|
Funciones de acceso:
| qreal | z() const |
| void | setZ(qreal) |
Señal de aviso:
| void | zChanged() |
Documentación de funciones miembro
[explicit] QQuickItem::QQuickItem(QQuickItem *parent = nullptr)
Construye un QQuickItem con la dirección parent.
parent se utilizará como padre de visual parent y de QObject.
[override virtual noexcept] QQuickItem::~QQuickItem()
Destruye el QQuickItem.
bool QQuickItem::acceptHoverEvents() const
Devuelve si los eventos hover son aceptados por este elemento.
El valor por defecto es false.
Si es false, el elemento no recibirá eventos hover a través de las funciones hoverEnterEvent(), hoverMoveEvent() y hoverLeaveEvent().
Véase también setAcceptHoverEvents().
bool QQuickItem::acceptTouchEvents() const
Devuelve si los eventos táctiles son aceptados por este elemento.
El valor por defecto es false.
Si es false, entonces el elemento no recibirá ningún evento táctil a través de la función touchEvent().
Véase también setAcceptTouchEvents().
Qt::MouseButtons QQuickItem::acceptedMouseButtons() const
Devuelve los botones del ratón aceptados por este elemento.
El valor por defecto es Qt::NoButton; es decir, no se acepta ningún botón del ratón.
Si un elemento no acepta el botón del ratón para un evento del ratón en particular, el evento del ratón no será entregado al elemento y será entregado al siguiente elemento en la jerarquía de elementos en su lugar.
Véase también setAcceptedMouseButtons() y acceptTouchEvents().
[virtual] QRectF QQuickItem::boundingRect() const
Devuelve las extensiones del elemento en su propio sistema de coordenadas: un rectángulo desde 0, 0 hasta width() y height().
[invokable] QQuickItem *QQuickItem::childAt(qreal x, qreal y) const
Devuelve el primer elemento hijo visible encontrado en el punto (x, y) dentro del sistema de coordenadas de este elemento.
Devuelve nullptr si no existe tal elemento.
Nota: Esta función puede invocarse a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.
QList<QQuickItem *> QQuickItem::childItems() const
Devuelve los hijos de este elemento.
[virtual protected] bool QQuickItem::childMouseEventFilter(QQuickItem *item, QEvent *event)
Reimplemente este método para filtrar los eventos de puntero que reciben los hijos de este elemento.
Este método sólo será llamado si filtersChildMouseEvents() es true.
Devuelve true si el event especificado no debe pasarse al item hijo especificado , y false en caso contrario. Si devuelve true, también debe accept o ignore el event, para señalar si la propagación de eventos debe detenerse o continuar. El event, sin embargo, siempre será enviado a todos los childMouseEventFilters de la cadena padre.
Nota: A pesar del nombre, esta función filtra todas las instancias de QPointerEvent durante el envío a todos los hijos (típicamente eventos de ratón, táctiles y de tableta). Cuando sobrescriba esta función en una subclase, le sugerimos que escriba código genérico de gestión de eventos utilizando únicamente los accesores que se encuentran en QPointerEvent. Alternativamente puedes activar event->type() y/o event->device()->type() para manejar diferentes tipos de eventos de diferentes maneras.
Nota: El filtrado es sólo una forma de compartir la responsabilidad en caso de ambigüedad gestual (por ejemplo, al pulsar, no sabes si el usuario va a tocar o arrastrar). Otra forma es llamar a QPointerEvent::addPassiveGrabber() al pulsar, para monitorizar de forma no exclusiva el progreso de QEventPoint. En cualquier caso, el manejador del elemento o puntero que está monitorizando puede robar el agarre exclusivo más tarde, cuando quede claro que el gesto se ajusta al patrón que está esperando.
Véase también setFiltersChildMouseEvents().
[override virtual protected] void QQuickItem::classBegin()
Reimplementa: QQmlParserStatus::classBegin().
Las clases derivadas deben llamar al método de la clase base antes de añadir su propia acción a realizar en classBegin.
[virtual] QRectF QQuickItem::clipRect() const
Devuelve el área rectangular dentro de este elemento que es visible actualmente en viewportItem(), si hay un viewport y la bandera ItemObservesViewport está activada; en caso contrario, las extensiones de este elemento en su propio sistema de coordenadas: un rectángulo desde 0, 0 hasta width() y height(). Esta es la región que debe permanecer visible si clip es true. También puede utilizarse en updatePaintNode() para limitar los gráficos añadidos al gráfico de la escena.
Por ejemplo, un dibujo grande o un documento de texto grande puede mostrarse en un Flickable que ocupe sólo parte de la ventana de la aplicación: en ese caso, Flickable es el elemento viewport, y un elemento de renderizado de contenido personalizado puede optar por omitir los nodos del gráfico de escena que queden fuera del área visible en ese momento. Si se activa el indicador ItemObservesViewport, esta área cambiará cada vez que el usuario desplace el contenido del elemento Flickable.
En el caso de elementos de vista anidados, clipRect() es la intersección de los boundingRects de todos los ancestros que tengan la bandera ItemIsViewport activada, mapeada al sistema de coordenadas de este elemento.
Véase también boundingRect().
[override virtual protected] void QQuickItem::componentComplete()
Reimplementa: QQmlParserStatus::componentComplete().
Las clases derivadas deben llamar al método de la clase base antes de añadir sus propias acciones a realizar en componentComplete.
[virtual invokable] bool QQuickItem::contains(const QPointF &point) const
Devuelve true si este elemento contiene point, que está en coordenadas locales; devuelve false en caso contrario.
Esta función puede sobreescribirse para manejar colisiones de puntos en elementos con formas personalizadas. La implementación por defecto comprueba si el punto está dentro de containmentMask() si está establecido, o dentro de la caja delimitadora en caso contrario.
Nota: Este método se utiliza para comprobar cada QEventPoint durante la entrega del evento, por lo que la implementación debe ser lo más ligera posible.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
QCursor QQuickItem::cursor() const
Devuelve la forma del cursor para este elemento.
El cursor del ratón asumirá esta forma cuando esté sobre este elemento, a menos que se establezca un cursor de anulación. Véase list of predefined cursor objects para una gama de formas útiles.
Si no se ha establecido ninguna forma de cursor, devuelve un cursor con la forma Qt::ArrowCursor, aunque puede mostrarse otra forma de cursor si un elemento superpuesto tiene un cursor válido.
Véase también setCursor() y unsetCursor().
[virtual protected] void QQuickItem::dragEnterEvent(QDragEnterEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastrar-entrar para un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
Véase también Drag y Arrastrar y soltar.
[virtual protected] void QQuickItem::dragLeaveEvent(QDragLeaveEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastre-abandono de un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
Véase también Drag y Arrastrar y soltar.
[virtual protected] void QQuickItem::dragMoveEvent(QDragMoveEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de arrastrar-mover para un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
Véase también Drag y Arrastrar y soltar.
[virtual protected] void QQuickItem::dropEvent(QDropEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de caída de un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos de arrastrar y soltar sólo se proporcionan si se ha establecido la bandera ItemAcceptsDrops para este elemento.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
Véase también Drag y Arrastrar y soltar.
[invokable, since 6.3] void QQuickItem::dumpItemTree() const
Vuelca algunos detalles sobre el árbol visual de los ítems que comienzan con este ítem, recursivamente.
Nota: QObject::dumpObjectTree() vuelca un árbol similar; pero, como se explica en Conceptos - Visual Parent en Qt Quick, QObject::parent() de un elemento a veces difiere de su QQuickItem::parentItem(). Puede volcar ambos árboles para ver la diferencia.
Nota: El formato exacto de salida puede cambiar en futuras versiones de Qt.
Nota: Esta función puede ser invocada a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.
Esta función se introdujo en Qt 6.3.
Véase también Técnicas de depuración y GammaRay's Qt Quick Inspector.
[invokable, since 6.3] void QQuickItem::ensurePolished()
Llama a updatePolish()
Esto puede ser útil para elementos como Layouts (o Posicionadores) que retrasan el cálculo de sus implicitWidth y implicitHeight hasta que reciben un PolishEvent.
Normalmente, si, por ejemplo, se añade o elimina un elemento hijo a un Layout, el tamaño implícito no se calcula inmediatamente (esto es una optimización). En algunos casos puede ser deseable consultar el tamaño implícito del layout justo después de añadir un elemento hijo. Si este es el caso, utilice esta función justo antes de consultar el tamaño implícito.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Esta función se introdujo en Qt 6.3.
Véase también updatePolish() y polish().
[override virtual protected] bool QQuickItem::event(QEvent *ev)
Reimplementa: QObject::event(QEvent *e).
bool QQuickItem::filtersChildMouseEvents() const
Devuelve si los eventos de puntero destinados a los elementos hijos de este elemento deben filtrarse a través de este elemento.
Si tanto este elemento como un elemento hijo tienen acceptTouchEvents() true, cuando se produzca una interacción táctil, este elemento filtrará el evento táctil. Pero si este elemento o el hijo no pueden manejar eventos táctiles, childMouseEventFilter() será llamado con un evento de ratón sintetizado.
Véase también setFiltersChildMouseEvents() y childMouseEventFilter().
QQuickItem::Flags QQuickItem::flags() const
Devuelve las banderas de artículo de este artículo.
Véase también setFlags() y setFlag().
[virtual protected] void QQuickItem::focusInEvent(QFocusEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de enfoque de un ítem. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
Si reimplementa esta función, debe llamar a la implementación de la clase base.
[virtual protected] void QQuickItem::focusOutEvent(QFocusEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de focus-out para un ítem. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[invokable] void QQuickItem::forceActiveFocus()
Fuerza el enfoque activo en el elemento.
Este método establece el foco en el elemento y asegura que todos los objetos FocusScope ancestros en la jerarquía de objetos también reciban focus.
La razón del cambio de foco será Qt::OtherFocusReason. Utilice el método sobrecargado para especificar la razón del foco para permitir un mejor manejo del cambio de foco.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también activeFocus.
[invokable] void QQuickItem::forceActiveFocus(Qt::FocusReason reason)
Fija el foco activo en el elemento con el valor reason.
Este método establece el foco en el elemento y garantiza que todos los objetos FocusScope antecesores en la jerarquía de objetos también reciban focus.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Se trata de una función sobrecargada.
Véase también activeFocus y Qt::FocusReason.
[virtual protected, since 6.0] void QQuickItem::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
Esta función es llamada para manejar los cambios de geometría de este ítem de oldGeometry a newGeometry. Si las dos geometrías son iguales, no hace nada.
Las clases derivadas deben llamar al método de la clase base dentro de su implementación.
Esta función se introdujo en Qt 6.0.
QSharedPointer<QQuickItemGrabResult> QQuickItem::grabToImage(const QSize &targetSize = QSize())
Recoge el elemento en una imagen en memoria.
La captura se produce de forma asíncrona y la señal QQuickItemGrabResult::ready() se emite cuando la captura se ha completado.
Utilice targetSize para especificar el tamaño de la imagen de destino. Por defecto, el resultado tendrá el mismo tamaño que item.
Si no se ha podido iniciar la captura, la función devuelve null.
Nota: Esta función renderizará el elemento en una superficie fuera de la pantalla y copiará esa superficie de la memoria de la GPU a la memoria de la CPU, lo que puede resultar bastante costoso. Para una previsualización "en vivo", utilice layers o ShaderEffectSource.
Véase también QQuickWindow::grabWindow().
[protected] bool QQuickItem::heightValid() const
Devuelve si la propiedad de altura se ha establecido explícitamente.
[virtual protected] void QQuickItem::hoverEnterEvent(QHoverEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-enter de un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.
El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::hoverLeaveEvent(QHoverEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-leave de un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.
El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::hoverMoveEvent(QHoverEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos hover-move de un ítem. La información del evento es proporcionada por el parámetro event.
Los eventos hover sólo se proporcionan si acceptHoverEvents() es true.
El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
qreal QQuickItem::implicitWidth() const
Devuelve la anchura del elemento que está implícita en otras propiedades que determinan el contenido.
Nota: Función Getter para la propiedad implicitWidth.
Véase también setImplicitWidth().
[virtual protected] void QQuickItem::inputMethodEvent(QInputMethodEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de métodos de entrada para un elemento. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual] QVariant QQuickItem::inputMethodQuery(Qt::InputMethodQuery query) const
Este método sólo es relevante para los elementos de entrada.
Si este elemento es un elemento de entrada, este método debería reimplementarse para devolver los indicadores de método de entrada relevantes para el query dado.
Véase también QWidget::inputMethodQuery().
bool QQuickItem::isAncestorOf(const QQuickItem *child) const
Devuelve true si este elemento es un antepasado de child (es decir, si este elemento es el padre de child o uno de los antepasados del padre de child).
Véase también parentItem().
[protected] bool QQuickItem::isComponentComplete() const
Devuelve true si se ha completado la construcción del componente QML; en caso contrario, devuelve false.
A menudo es conveniente retrasar algún proceso hasta que el componente se haya completado.
Véase también componentComplete().
bool QQuickItem::isFocusScope() const
Devuelve true si este elemento es un ámbito de enfoque, y false en caso contrario.
[virtual] bool QQuickItem::isTextureProvider() const
Devuelve true si este elemento es un proveedor de textura. La implementación por defecto devuelve false.
Esta función puede ser llamada desde cualquier hilo.
[virtual protected] void QQuickItem::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
Se llama cuando se produce change para este elemento.
value contiene información adicional relativa al cambio, cuando procede.
Si reimplementa este método en una subclase, asegúrese de llamar a
QQuickItem::itemChange(change, value);
típicamente al final de su implementación, para asegurarse de que se emita la señal windowChanged().
bool QQuickItem::keepMouseGrab() const
Devuelve si la entrada del ratón debe permanecer exclusivamente en este elemento.
Véase también setKeepMouseGrab(), QEvent::accept() y QEvent::ignore().
bool QQuickItem::keepTouchGrab() const
Devuelve si los puntos de contacto capturados por este elemento deben permanecer exclusivamente con este elemento.
Véase también setKeepTouchGrab(), keepMouseGrab(), QEvent::accept() y QEvent::ignore().
[virtual protected] void QQuickItem::keyPressEvent(QKeyEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de pulsación de teclas para un elemento. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::keyReleaseEvent(QKeyEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de liberación de teclas para un elemento. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[invokable] QPointF QQuickItem::mapFromGlobal(const QPointF &point) const
Mapea el point dado en el sistema global de coordenadas de la pantalla al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Por ejemplo, esto puede ser útil para añadir una ventana emergente a un componente Qt Quick.
Nota: el posicionamiento de la ventana lo realiza el gestor de ventanas y este valor se trata sólo como una sugerencia. Por lo tanto, la posición resultante de la ventana puede diferir de la esperada.
Nota: Si este elemento está en una subescena, por ejemplo, mapeado en un objeto 3D Model, el mapeado UV se incorpora en esta transformación, de modo que realmente va desde las coordenadas de la pantalla a las coordenadas de este elemento, siempre y cuando point esté realmente dentro de los límites de este elemento. Las otras funciones de mapeado aún no trabajan de esa manera.
Nota: Esta función puede invocarse a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
[invokable] QPointF QQuickItem::mapFromItem(const QQuickItem *item, const QPointF &point) const
Asigna el punto point dado en el sistema de coordenadas de item al punto equivalente dentro del sistema de coordenadas de este elemento y devuelve la coordenada asignada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Si item es nullptr, esto mapea point desde el sistema de coordenadas de la escena.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QPointF QQuickItem::mapFromScene(const QPointF &point) const
Mapea el point dado en el sistema de coordenadas de la escena al punto equivalente dentro del sistema de coordenadas de este elemento, y devuelve la coordenada mapeada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QRectF QQuickItem::mapRectFromItem(const QQuickItem *item, const QRectF &rect) const
Mapea el rect dado en el sistema de coordenadas de item al área rectangular equivalente dentro del sistema de coordenadas de este elemento, y devuelve el valor del rectángulo mapeado.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Si item es nullptr, esto mapea rect desde el sistema de coordenadas de la escena.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QRectF QQuickItem::mapRectFromScene(const QRectF &rect) const
Mapea el rect dado en el sistema de coordenadas de la escena al área rectangular equivalente dentro del sistema de coordenadas de este elemento, y devuelve el valor del rectángulo mapeado.
Las siguientes propiedades del elemento se utilizan en la asignación: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QRectF QQuickItem::mapRectToItem(const QQuickItem *item, const QRectF &rect) const
Mapea el rect dado en el sistema de coordenadas de este elemento al área rectangular equivalente dentro del sistema de coordenadas de item y devuelve el valor del rectángulo mapeado.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Si item es nullptr, esto mapea rect al sistema de coordenadas de la escena.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QRectF QQuickItem::mapRectToScene(const QRectF &rect) const
Mapea el rect dado en el sistema de coordenadas de este elemento al área rectangular equivalente dentro del sistema de coordenadas de la escena, y devuelve el valor del rectángulo mapeado.
Las siguientes propiedades del elemento se utilizan en la asignación: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
[invokable] QPointF QQuickItem::mapToGlobal(const QPointF &point) const
Mapea el point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema global de coordenadas de la pantalla, y devuelve la coordenada mapeada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Por ejemplo, esto puede ser útil para añadir una ventana emergente a un componente Qt Quick.
Nota: el posicionamiento de la ventana lo realiza el gestor de ventanas y este valor se trata sólo como una sugerencia. Por lo tanto, la posición resultante de la ventana puede diferir de la esperada.
Nota: Esta función puede ser invocada a través del sistema de meta-objetos y desde QML. Véase Q_INVOKABLE.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
[invokable] QPointF QQuickItem::mapToItem(const QQuickItem *item, const QPointF &point) const
Asigna el punto point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de item y devuelve la coordenada asignada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeo incluye la posición relativa de las dos escenas.
Si item es nullptr, esto mapea point al sistema de coordenadas de la escena.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
QPointF QQuickItem::mapToScene(const QPointF &point) const
Mapea el point dado en el sistema de coordenadas de este elemento al punto equivalente dentro del sistema de coordenadas de la escena, y devuelve la coordenada mapeada.
Las siguientes propiedades del elemento se utilizan en el mapeo: x, y, scale, rotation, transformOrigin, y transform.
Si los elementos forman parte de escenas diferentes, el mapeado incluye la posición relativa de las dos escenas.
Véase también Conceptos - Coordenadas visuales en Qt Quick.
[virtual protected] void QQuickItem::mouseDoubleClickEvent(QMouseEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de doble clic del ratón para un elemento. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::mouseMoveEvent(QMouseEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de movimiento del ratón para un ítem. La información del evento es proporcionada por el parámetro event.
Para recibir eventos de movimiento del ratón, el evento de pulsación del ratón precedente debe ser aceptado (anulando mousePressEvent(), por ejemplo) y acceptedMouseButtons() debe devolver el botón del ratón correspondiente.
El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si se reimplementa esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::mousePressEvent(QMouseEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de pulsación del ratón para un elemento. La información del evento es proporcionada por el parámetro event.
Para recibir eventos de pulsación del ratón, acceptedMouseButtons() debe devolver el botón del ratón correspondiente.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::mouseReleaseEvent(QMouseEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de liberación del ratón para un ítem. La información del evento es proporcionada por el parámetro event.
Para recibir eventos de liberación del ratón, el evento precedente de pulsación del ratón debe ser aceptado (anulando mousePressEvent(), por ejemplo) y acceptedMouseButtons() debe devolver el botón del ratón correspondiente.
El evento se acepta por defecto, por lo que no es necesario aceptarlo explícitamente si se reimplementa esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::mouseUngrabEvent()
Este manejador de eventos puede ser reimplementado en una subclase para ser notificado cuando un evento de desenganche del ratón ha ocurrido en este ítem.
[invokable] QQuickItem *QQuickItem::nextItemInFocusChain(bool forward = true)
Devuelve el elemento de la cadena de enfoque que se encuentra junto a este elemento. Si forward es true, o no se proporciona, es el siguiente elemento en la dirección hacia delante. Si forward es false, es el siguiente elemento en la dirección hacia atrás.
Nota: Esta función puede invocarse a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.
void QQuickItem::polish()
Programa un evento de pulido para este elemento.
Cuando el gráfico de escena procese la solicitud, llamará a updatePolish() en este elemento.
Ver también updatePolish(), QQuickTest::qIsPolishScheduled(), y ensurePolished().
[virtual protected] void QQuickItem::releaseResources()
Se llama a esta función cuando un elemento debe liberar recursos gráficos que aún no están gestionados por los nodos devueltos por QQuickItem::updatePaintNode().
Esto ocurre cuando el elemento está a punto de ser eliminado de la ventana en la que se estaba renderizando previamente. Se garantiza que el elemento tiene un window cuando se llama a la función.
La función es llamada en el hilo GUI y el estado del hilo de renderizado, cuando se utiliza, es desconocido. Los objetos no deben borrarse directamente, sino programarse para su limpieza utilizando QQuickWindow::scheduleRenderJob().
Véase también Graphics Resource Handling.
QQuickItem *QQuickItem::scopedFocusItem() const
Si este elemento es un ámbito de foco, devuelve el elemento de su cadena de foco que actualmente tiene foco.
Devuelve nullptr si este elemento no es un ámbito de enfoque.
void QQuickItem::setAcceptHoverEvents(bool enabled)
Si enabled es verdadero, el elemento acepta eventos hover; en caso contrario, no acepta eventos hover.
Véase también acceptHoverEvents().
void QQuickItem::setAcceptTouchEvents(bool enabled)
Si enabled es verdadero, el elemento acepta eventos táctiles; en caso contrario, no acepta eventos táctiles.
Véase también acceptTouchEvents().
void QQuickItem::setAcceptedMouseButtons(Qt::MouseButtons buttons)
Establece los botones del ratón aceptados por este elemento en buttons.
Nota: En Qt 5, llamar a setAcceptedMouseButtons() causaba implícitamente que un elemento recibiera eventos táctiles así como eventos de ratón; pero se recomendaba llamar a setAcceptTouchEvents() para suscribirse a ellos. En Qt 6, es necesario llamar a setAcceptTouchEvents() para seguir recibiéndolos.
Véase también acceptedMouseButtons().
void QQuickItem::setCursor(const QCursor &cursor)
Establece la forma cursor para este elemento.
Véase también cursor() y unsetCursor().
void QQuickItem::setFiltersChildMouseEvents(bool filter)
Establece si los eventos de puntero destinados a los elementos hijos de este elemento deben filtrarse a través de este elemento.
Si filter es verdadero, se llamará a childMouseEventFilter() cuando se active un evento de puntero para un elemento hijo.
Véase también filtersChildMouseEvents().
void QQuickItem::setFlag(QQuickItem::Flag flag, bool enabled = true)
Activa el indicador flag especificado para este elemento si enabled es verdadero; si enabled es falso, el indicador se desactiva.
Proporcionan varias sugerencias para el elemento; por ejemplo, la bandera ItemClipsChildrenToShape indica que todos los hijos de este elemento deben recortarse para que quepan dentro del área del elemento.
void QQuickItem::setFlags(QQuickItem::Flags flags)
Habilita el flags especificado para este elemento.
Véase también flags() y setFlag().
void QQuickItem::setFocusPolicy(Qt::FocusPolicy policy)
Establece la política de enfoque de este elemento en policy.
Nota: Función Setter para la propiedad focusPolicy.
Véase también focusPolicy().
void QQuickItem::setKeepMouseGrab(bool keep)
Establece si la entrada del ratón debe permanecer exclusivamente con este elemento.
Esto es útil para elementos que desean agarrar y mantener la interacción del ratón siguiendo un gesto predefinido. Por ejemplo, un elemento que está interesado en el movimiento horizontal del ratón puede establecer keepMouseGrab a true una vez que se ha superado un umbral. Una vez que keepMouseGrab se ha establecido en true, los elementos de filtrado no reaccionarán a los eventos del ratón.
Si keep es falso, un elemento de filtrado puede robar el agarre. Por ejemplo, Flickable puede intentar robar una captura del ratón si detecta que el usuario ha empezado a mover la ventana gráfica.
Véase también keepMouseGrab().
void QQuickItem::setKeepTouchGrab(bool keep)
Establece si los puntos táctiles capturados por este elemento deben permanecer exclusivamente con este elemento.
Esto es útil para elementos que desean agarrar y mantener puntos táctiles específicos siguiendo un gesto predefinido. Por ejemplo, un elemento interesado en el movimiento horizontal de los puntos táctiles puede establecer setKeepTouchGrab en true una vez superado un umbral. Una vez que setKeepTouchGrab se ha establecido en true, los elementos de filtrado no reaccionarán a los puntos táctiles relevantes.
Si keep es falso, un elemento filtrante puede robar el agarre. Por ejemplo, Flickable puede intentar robar la captura de un punto táctil si detecta que el usuario ha empezado a mover la ventana gráfica.
Véase también keepTouchGrab() y setKeepMouseGrab().
void QQuickItem::setSize(const QSizeF &size)
Establece el tamaño del elemento en size. Este método conserva cualquier vinculación existente sobre la anchura y la altura; por lo tanto, cualquier cambio que provoque que la vinculación se ejecute de nuevo anulará los valores establecidos.
Véase también size, setWidth, y setHeight.
QSizeF QQuickItem::size() const
Devuelve el tamaño del elemento.
Véase también setSize, width, y height.
void QQuickItem::stackAfter(const QQuickItem *sibling)
Mueve este elemento al índice posterior al elemento hermano especificado dentro de la lista de hijos. El orden de los hijos afecta tanto al orden de apilamiento visual como al orden de navegación del foco de la pestaña.
Asumiendo que los valores z de ambos elementos son los mismos, esto hará que sibling se muestre debajo de este elemento.
Si ambos elementos tienen activeFocusOnTab establecido en true, esto también causará que el orden de enfoque de la pestaña cambie, con sibling recibiendo el enfoque antes que este elemento.
El sibling dado debe ser un hermano de este elemento; es decir, deben tener el mismo parent inmediato.
Véase también Conceptos - Visual Parent en Qt Quick.
void QQuickItem::stackBefore(const QQuickItem *sibling)
Mueve este elemento al índice anterior al elemento hermano especificado dentro de la lista de hijos. El orden de los elementos secundarios afecta tanto al orden de apilamiento visual como al orden de navegación de las pestañas.
Asumiendo que los valores z de ambos elementos son los mismos, esto hará que sibling se muestre por encima de este elemento.
Si ambos elementos tienen activeFocusOnTab establecido en true, esto también hará que el orden de enfoque de la pestaña cambie, con sibling recibiendo el enfoque después de este elemento.
El sibling dado debe ser un hermano de este elemento; es decir, deben tener el mismo parent inmediato.
Véase también Conceptos - Visual Parent en Qt Quick.
[virtual] QSGTextureProvider *QQuickItem::textureProvider() const
Devuelve el proveedor de textura de un elemento. La implementación por defecto devuelve nullptr.
Esta función sólo puede ser llamada en el hilo de renderizado.
[virtual protected] void QQuickItem::touchEvent(QTouchEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos táctiles de un ítem. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[virtual protected] void QQuickItem::touchUngrabEvent()
Este manejador de eventos puede ser reimplementado en una subclase para ser notificado cuando un evento de desasimiento táctil ha ocurrido en este ítem.
void QQuickItem::unsetCursor()
Borra la forma del cursor para este elemento.
Véase también cursor() y setCursor().
[slot] void QQuickItem::update()
Programa una llamada a updatePaintNode() para este elemento.
La llamada a QQuickItem::updatePaintNode() siempre se producirá si el elemento se muestra en QQuickWindow.
Sólo los elementos que especifican QQuickItem::ItemHasContents pueden llamar a QQuickItem::update().
[protected] void QQuickItem::updateInputMethod(Qt::InputMethodQueries queries = Qt::ImQueryInput)
Notifica al método de entrada los valores de consulta actualizados si es necesario. queries indica los atributos modificados.
[virtual protected] QSGNode *QQuickItem::updatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *updatePaintNodeData)
Llamada en el hilo de renderizado cuando es el momento de sincronizar el estado del ítem con el gráfico de escena.
La función es llamada como resultado de QQuickItem::update(), si el usuario ha establecido la bandera QQuickItem::ItemHasContents en el elemento.
La función debe devolver la raíz del subárbol del grafo de escena para este elemento. La mayoría de las implementaciones devolverán un único QSGGeometryNode que contiene la representación visual de este elemento. oldNode es el nodo que se devolvió la última vez que se llamó a la función. updatePaintNodeData proporciona un puntero al QSGTransformNode asociado con este QQuickItem.
QSGNode *MyItem::updatePaintNode(QSGNode *node, UpdatePaintNodeData *) { QSGSimpleRectNode *n = static_cast<QSGSimpleRectNode *>(node); if (!n) { n = new QSGSimpleRectNode(); n->setColor(Qt::red); } n->setRect(boundingRect()); return n; }
El hilo principal está bloqueado mientras se ejecuta esta función, por lo que es seguro leer valores de la instancia QQuickItem y otros objetos en el hilo principal.
Si ninguna llamada a QQuickItem::updatePaintNode() resulta en cambios reales en el gráfico de la escena, como QSGNode::markDirty() o añadir y eliminar nodos, entonces la implementación subyacente puede decidir no renderizar la escena de nuevo ya que el resultado visual es idéntico.
Advertencia: Es crucial que las operaciones gráficas y la interacción con el grafo de escena ocurran exclusivamente en el hilo de renderizado, principalmente durante la llamada a QQuickItem::updatePaintNode(). La mejor regla es usar solo clases con el prefijo "QSG" dentro de la función QQuickItem::updatePaintNode().
Advertencia: Esta funcion es llamada en el hilo de renderizado. Esto significa que cualquier QObjects o hilo de almacenamiento local que se cree tendrá afinidad con el hilo de renderizado, así que ten cuidado cuando hagas algo que no sea renderizar en esta función. De manera similar para las señales, estas serán emitidas en el hilo de renderizado y por lo tanto a menudo serán entregadas a través de conexiones en cola.
Nota: Todas las clases con el prefijo QSG deben ser usadas únicamente en el hilo de renderizado del gráfico de escena. Ver Gráfico de Escena y Renderizado para más información.
Véase también QSGMaterial, QSGGeometryNode, QSGGeometry, QSGFlatColorMaterial, QSGTextureMaterial, QSGNode::markDirty(), y Graphics Resource Handling.
[virtual protected] void QQuickItem::updatePolish()
Esta función debe realizar cualquier diseño que se requiera para este elemento.
Cuando se llama a polish(), el gráfico de escena programa un evento de pulido para este elemento. Cuando el grafo de escena está listo para renderizar este ítem, llama a updatePolish() para realizar cualquier diseño requerido antes de renderizar el siguiente cuadro.
Véase también ensurePolished().
QQuickItem *QQuickItem::viewportItem() const
Si la opción ItemObservesViewport está activada, devuelve el elemento padre más cercano con la opción ItemIsViewport. Devuelve el elemento de contenido de la ventana si la bandera no está activada, o si no se encuentra ningún otro elemento de la ventana gráfica.
Devuelve nullptr sólo si no hay ningún elemento en la ventana gráfica y este elemento no se muestra en una ventana.
Véase también clipRect().
[virtual protected] void QQuickItem::wheelEvent(QWheelEvent *event)
Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de rueda para un ítem. La información del evento es proporcionada por el parámetro event.
El evento es aceptado por defecto, por lo que no es necesario aceptarlo explícitamente si reimplementas esta función. Si no acepta el evento, llame a event->ignore().
[protected] bool QQuickItem::widthValid() const
Devuelve si la propiedad width se ha establecido explícitamente.
QQuickWindow *QQuickItem::window() const
Devuelve la ventana en la que se representa este elemento.
El elemento no tiene una ventana hasta que ha sido asignado a una escena. La señal windowChanged() proporciona una notificación tanto cuando el elemento se introduce en una escena como cuando se elimina de una escena.
[signal] void QQuickItem::windowChanged(QQuickWindow *window)
Esta señal se emite cuando cambia la dirección window del artículo.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.







