QQuickItem Class

All visual QML items are rendered using the scene graph, the default implementation of which is a low-level, high-performance rendering stack, closely tied to accelerated graphics APIs, such as OpenGL, Vulkan, Metal, or Direct 3D. It is possible for subclasses of QQuickItem to add their own custom content into the scene graph by setting the QQuickItem::ItemHasContents flag and reimplementing the QQuickItem::updatePaintNode() function.

Graphics Resource Handling▲

The QQuickItem provides a subclass, QQuickPaintedItem, which allows the users to render content using QPainter.

If your Item uses the Behavior type to define animations for property changes, you should always use either QObject::setProperty(), QQmlProperty(), or QMetaProperty::write() when you need to modify those properties from C++. This ensures that the QML engine knows about the property change. Otherwise, the engine won't be able to carry out your requested animation. Note that these functions incur a slight performance penalty. For more details, see Accessing Members of a QML Object Type from C++.

See also QQuickWindow, QQuickPaintedItem

flags QQuickItem::Flags

This enum type is used to specify various item properties.

The Flags type is a typedef for QFlags<Flag>. It stores an OR combination of Flag values.

See Also▲

Used in conjunction with QQuickItem::itemChange() to notify the item about certain types of changes.

Controls the point about which simple transforms like scale apply.

See Also▲

implicitWidth : qreal

Defines the preferred width or height of the Item.

If width or height is not specified, an item's effective size will be determined by its implicitWidth or implicitHeight.

However, if an item is the child of a layout, the layout will determine the item's preferred size using its implicit size. In such a scenario, the explicit width or height will be ignored.

The default implicit size for most items is 0x0, however some items have an inherent implicit size which cannot be overridden, for example, Image and Text.

Setting the implicit size is useful for defining components that have a preferred size based on their content, for example:

// 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
    }
}

This read-only property indicates whether the item has active focus.

If activeFocus is true, either this item is the one that currently receives keyboard input, or it is a FocusScope ancestor of the item that currently receives keyboard input.

Usually, activeFocus is gained by setting focus on an item and its enclosing FocusScope objects. In the following example, the input and focusScope objects will have active focus, while the root rectangle object will not.

import QtQuick 2.0

Rectangle {
    width: 100; height: 100

    FocusScope {
        focus: true

        TextInput {
            id: input
            focus: true
        }
    }
}

Access functions:

• bool hasActiveFocus() const

Notifier signal:

• void activeFocusChanged(bool)

See Also▲

This property holds whether the item wants to be in the tab focus chain. By default, this is set to false.

Access functions:

• bool activeFocusOnTab() const

• void setActiveFocusOnTab(bool)

Notifier signal:

• void activeFocusOnTabChanged(bool)

Specifies whether the item is antialiased or not

Used by visual elements to decide if the item should use antialiasing or not. In some cases items with antialiasing require more memory and are potentially slower to render (see Antialiasing for more details).

The default is false, but may be overridden by derived elements.

Access functions:

• bool antialiasing() const

• void setAntialiasing(bool)

• void resetAntialiasing()

Notifier signal:

• void antialiasingChanged(bool)

Specifies the position of the item's baseline in local coordinates.

The baseline of a Text item is the imaginary line on which the text sits. Controls containing text usually set their baseline to the baseline of their text.

For non-text items, a default baseline offset of 0 is used.

Access functions:

• qreal baselineOffset() const

• void setBaselineOffset(qreal)

Notifier signal:

• void baselineOffsetChanged(qreal)

This property holds the collective position and size of the item's children.

This property is useful if you need to access the collective geometry of an item's children in order to correctly size the item.

The geometry that is returned is local to the item. For example:

Item {
    x: 50
    y: 100

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

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

Access functions:

• childrenRect()

Notifier signal:

• void childrenRectChanged(const QRectF &)

This property holds whether cli