Defining Object Types through QML Documents

To create an object type, a QML document should be placed into a text file named as <TypeName>.qml where <TypeName> is the desired name of the type. The type name has the following requirements:

• It must be comprised of alphanumeric characters or underscores.

• It must begin with an uppercase letter.

This document is then automatically recognized by the engine as a definition of a QML type. Additionally, a type defined in this manner is automatically made available to other QML files within the same local directory as the engine searches within the immediate directory when resolving QML type names.

For example, below is a document that declares a Rectangle with a child MouseArea. The document has been saved to file named SquareButton.qml:

// SquareButton.qml
import QtQuick 2.0

Rectangle {
    property int side: 100
    width: side; height: side
    color: "red"

    MouseArea {
        anchors.fill: parent
        onClicked: console.log("Button clicked!")
    }
}

Since the file is named SquareButton.qml, this can now be used as a type named SquareButton by any other QML file within the same directory. For example, if there was a myapplication.qml file in the same directory, it could refer to the SquareButton type:

// myapplication.qml
import QtQuick 2.0

SquareButton {}

This creates a 100 x 100 red Rectangle with an inner MouseArea, as defined in SquareButton.qml. When this myapplication.qml document is loaded by the engine, it loads the SquareButton.qml document as a component and instantiates it to create a SquareButton object.

The SquareButton type encapsulates the tree of QML objects declared in SquareButton.qml. When the QML engine instantiates a SquareButton object from this type, it is instantiating an object from the Rectangle tree declared in SquareButton.qml.

Sometimes, it can be inconvenient to create a new file for a type, for instance when reusing a small delegate in multiple views. If you don't actually need to expose the type, but only need to create an instance, Component is an option. But if you want to declare properties with the component types, or if you want to use it in multiple files, Component is not an option. In that case, you can use inline components. Inline components declare a new component inside of a file. The syntax for that is

component <component name> : BaseType {
    // declare properties and bindings here
}

Inside the file which declares the inline component, the type can be referenced simply by its name.

// Images.qml
import QtQuick 2.15

Item {
    component LabeledImage: Column {
        property alias source: image.source
        property alias caption: text.text

        Image {
            id: image
            width: 50
            height: 50
        }
        Text {
            id: text
            font.bold: true
        }
    }

    Row {
        LabeledImage {
            id: before
            source: "before.png"
            caption: "Before"
        }
        LabeledImage {
            id: after
            source: "after.png"
            caption: "After"
        }
    }
    property LabeledImage selectedImage: before
}

In other files, it has to be prefixed with the name of its containing component.

// LabeledImageBox.qml
import QtQuick 2.15

Rectangle {
    property alias caption: image.caption
    property alias source: image.source
    border.width: 2
    border.color: "black"
    Images.LabeledImage {
        id: image
    }
}

// A.qml
import QtQuick 2.15

Item {
    id: root
    property string message: "From A"
    component MyInlineComponent : Item {
        Component.onCompleted: console.log(root.message)
    }
}
// B.qml
import QtQuick 2.15

Item {
    A.MyInlineComponent {}
}

If SquareButton.qml was not in the same directory as myapplication.qml, the SquareButton type would need to be specifically made available through an import statement in myapplication.qml. It could be imported from a relative path on the file system, or as an installed module; see module for more details.

pragma Singleton declares the component defined in the QML document as singleton. Singletons are created only once per QML engine. In order to use a QML-declared singleton you also have to register it with its module. See qt_target_qml_sources for how to do this with CMake.

With this pragma you can define how assignments to list properties shall be handled in components defined in the QML document. By default, assigning to a list property appends to the list. You can explicitly request this behavior using the value Append. Alternatively, you can request the contents of list properties to always be replaced using Replace, or replaced if the property is not the default property using ReplaceIfNotDefault. For example:

pragma ListPropertyAssignBehavior: ReplaceIfNotDefault

The same declaration can also be given for C++-defined types. See QML_LIST_PROPERTY_ASSIGN_BEHAVIOR_APPEND, QML_LIST_PROPERTY_ASSIGN_BEHAVIOR_REPLACE, and QML_LIST_PROPERTY_ASSIGN_BEHAVIOR_REPLACE_IF_NOT_DEFAULT

With this pragma you can restrict components defined in this file to only create objects within their original context. This holds for inline components as well as Component elements explicitly or implicitly created as properties. If a component is bound to its context, you can safely use IDs from the rest of the file within the component. Otherwise, the engine and the QML tooling cannot know in advance what type, if any, such IDs will resolve to at run time.

In order to bind the components to their context specify the Bound argument:

pragma ComponentBehavior: Bound

The default is Unbound. You can also specify it explicitly. In a future version of Qt the default will change to Bound.

Delegate components bound to their context don't receive their own private contexts on instantiation. This means that model data can only be passed via required properties in this case. Passing model data via context properties will not work. This concerns delegates to e.g. Instantiator, Repeater, ListView, TableView, GridView, TreeView and in general anything that uses DelegateModel internally.

For example, the following will not work:

pragma ComponentBehavior: Bound
import QtQuick

ListView {
    delegate: Rectangle {
        color: model.myColor
    }
}

The delegate property of ListView is a component. Therefore, a Component is implicitly created around the Rectangle here. That component is bound to its context. It doesn't receive the context property model provided by ListView. To make it work, you'd have to write it this way:

pragma ComponentBehavior: Bound
import QtQuick

ListView {
    delegate: Rectangle {
        required property color myColor
        color: myColor
    }
}

You can nest components in a QML file. The pragma holds for all components in the file, no matter how deeply nested.