Атрибуты объектов QML

Каждый тип объекта QML имеет определённый набор атрибутов. Каждый экземпляр типа объекта создаётся с набором атрибутов, определённых для этого типа объекта. Существует несколько различных типов атрибутов, которые могут быть заданы, описание которых приведено ниже.

Атрибуты в объявлениях объектов

Объявление объекта в документе QML определяет новый тип. Оно также объявляет иерархию объектов, которая будет инициализирована при создании экземпляра этого вновь определённого типа.

Набор типов атрибутов объектов QML следующий:

• атрибут id
• атрибуты свойств
• атрибуты сигналов
• атрибуты обработчиков сигналов
• атрибуты методов
• присоединённые свойства и атрибуты присоединённых обработчиков сигналов

Эти атрибуты подробно описаны ниже.

Атрибут id

Каждый тип объекта QML имеет ровно один атрибут id. Этот атрибут предоставляется самим языком и не может быть переопределён или перекрыт любым типом объекта QML.

Значение может быть назначено атрибуту id экземпляра объекта, чтобы этот объект можно было идентифицировать и ссылаться на него другим объектам. Это id должно начинаться с маленькой буквы или символа подчеркивания и не может содержать символы, кроме букв, цифр и символов подчеркивания.

Ниже показан объект TextInput и объект Text. Значение атрибута id объекта TextInput установлено в "myTextInput". Объект Text устанавливает свойство text так, чтобы оно имело то же значение, что и свойство text объекта TextInput, ссылаясь на myTextInput.text. Теперь оба элемента будут отображать одинаковый текст:

import QtQuick 2.0

Column {
    width: 200; height: 200

    TextInput { id: myTextInput; text: "Hello World" }

    Text { text: myTextInput.text }
}

На объект можно сослаться по его атрибуту id из любой точки области видимости компонента, в котором он объявлен. Таким образом, значение атрибута id должно быть уникальным в пределах области видимости компонента. Дополнительную информацию см. в разделе Область видимости и разрешение имён.

После создания экземпляра объекта значение его атрибута id изменить нельзя. Хотя он может выглядеть как обычное свойство, атрибут id не является обычным атрибутом property, и к нему применяются особые семантические правила; например, в приведённом выше примере невозможно получить доступ к myTextInput.id.

Атрибуты свойств

Свойство — это атрибут объекта, которому можно назначить статическое значение или привязать его к динамическому выражению. Значение свойства можно прочитать другим объектам. Как правило, его также можно изменить другим объектом, если только определённый тип QML не запретил это для конкретного свойства.

Определение атрибутов свойств

Свойство может быть определено для типа в C++ путём регистрации Q_PROPERTY класса, который затем регистрируется в системе типов QML. Кроме того, пользовательское свойство типа объекта может быть определено в объявлении объекта в документе QML с помощью следующего синтаксиса:

[default] property <propertyType> <propertyName>

Таким образом, объявление объекта может сделать определённое значение доступным для внешних объектов или легче поддерживать некоторое внутреннее состояние.

Имена свойств должны начинаться с маленькой буквы и могут содержать только буквы, цифры и символы подчеркивания. Зарезервированные слова JavaScript не являются допустимыми именами свойств. Ключевое слово default необязательно и изменяет семантику объявляемого свойства. Дополнительную информацию об атрибуте свойства default см. в следующем разделе по умолчанию.

Объявление пользовательского свойства неявно создаёт сигнал изменения значения для этого свойства, а также связанный с ним обработчик сигнала, называемый on<ИмяСвойства>Changed, где <ИмяСвойства> — это имя свойства с заглавной первой буквой.

Например, следующее объявление объекта определяет новый тип, который наследуется от базового типа Rectangle. У него есть два новых свойства, и для одного из них реализован обработчик сигналов:

Rectangle {
    property color previousColor
    property color nextColor
    onNextColorChanged: console.log("The next color will be: " + nextColor.toString())
}

Допустимые типы в определениях пользовательских свойств

В качестве типов пользовательских свойств можно использовать любой из QML основных типов, за исключением типа перечисления. Например, все эти объявления свойств являются допустимыми:

Item {
    property int someNumber
    property string someString
    property url someUrl
}

(Значения перечислений — просто целые значения, и их можно использовать со значением типа int.)

Некоторые основные типы предоставляются модулем QtQuick и поэтому не могут использоваться в качестве типов свойств, если модуль не импортирован. Подробнее см. в документации QML основные типы.

Обратите внимание, что базовый тип var — это универсальный тип-заполнитель, который может содержать любой тип значения, включая списки и объекты:

property var someNumber: 1.5
property var someString: "abc"
property var someBool: true
property var someList: [1, 2, "three", "four"]
property var someObject: Rectangle { width: 100; height: 100; color: "red" }

Кроме того, в качестве типа свойства можно использовать любой QML тип объекта. Например:

property Item someItem
property Rectangle someRectangle

Это также относится к пользовательским QML типам. Если QML тип был определён в файле с именем ColorfulButton.qml (в каталоге, который затем импортировался клиентом), то свойство типа ColorfulButton также будет допустимым.

Присвоение значений атрибутам свойств

Значение свойства экземпляра объекта можно указать двумя способами:

• присвоение значения при инициализации
• императивное присвоение значения

В обоих случаях значение может быть либо статическим, либо выражением привязки.

Присвоение значения при инициализации

Синтаксис присвоения значения свойству при инициализации:

<propertyName> : <value>

Если необходимо, присвоение начального значения можно объединить с определением свойства в объявлении объекта. В этом случае синтаксис определения свойства становится:

[default] property <propertyType> <propertyName> : <value>

Следующий пример демонстрирует инициализацию значения свойства:

import QtQuick 2.0

Rectangle {
    color: "red"
    property color nextColor: "blue" // combined property declaration and initialization
}

Императивное присвоение значения

Императивное присвоение значения — это присвоение значению свойства (как статическое значение, так и выражение привязки) из императивного кода JavaScript. Синтаксис императивного присвоения значения — это просто оператор присваивания JavaScript, как показано ниже:

[<objectId>.]<propertyName> = value

Следующий пример демонстрирует императивное присвоение значения:

import QtQuick 2.0

Rectangle {
    id: rect
    Component.onCompleted: {
        rect.color = "red"
    }
}

Статические значения и значения выражений привязки

Как уже отмечалось, к свойству можно назначить два вида значений: статические значения и значения выражений привязки. Последние также известны как привязки свойств.

В этом примере показаны оба вида значений, присваиваемых свойствам:

import QtQuick 2.0

Rectangle {
    // both of these are static value assignments on initialization
    width: 400
    height: 200

    Rectangle {
        // both of these are binding expression value assignments on initialization
        width: parent.width / 2
        height: parent.height
    }
}

Примечание: Чтобы императивно назначить выражение привязки, выражение привязки должно быть заключено в функцию, которая передаётся в Qt.binding(), а затем значение, возвращаемое Qt.binding(), должно быть присвоено свойству. В отличие от этого, Qt.binding() не следует использовать при присвоении выражения привязки при инициализации. Дополнительную информацию см. в разделе Привязка свойств.

Безопасность типов

Свойства являются типобезопасными. Свойству можно присвоить только значение, соответствующее типу свойства.

Например, если свойство является вещественным, и вы попытаетесь присвоить ему строку, вы получите ошибку:

property int volume: "four"  // generates an error; the property's object will not be loaded

Аналогично, если свойству в ходе выполнения программы присваивается значение неправильного типа, новое значение не будет присвоено, и будет сгенерирована ошибка.

Для некоторых типов свойств нет естественного представления значения, и в этом случае двигатель QML автоматически выполняет преобразование строки в значение типа. Например, хотя свойства типа color хранят цвета, а не строки, вы можете присвоить строку "red" свойству цвета без сообщения об ошибке.

Список типов свойств, поддерживаемых по умолчанию, см. в QML основные типы. Кроме того, в качестве типа свойства можно также использовать любой доступный QML тип объекта.

Специальные типы свойств

Атрибуты свойства списка объектов

Свойству типа список можно присвоить список значений QML типа объекта. Синтаксис для определения значения списка объектов — это список значений, разделённых запятыми, заключённый в квадратные скобки:

[ <item 1>, <item 2>, ... ]

Например, тип Item имеет свойство states, которое используется для хранения списка объектов типа State. В приведённом ниже коде значение этого свойства инициализируется списком из трёх объектов типа State:

import QtQuick 2.0

Item {
    states: [
        State { name: "loading" },
        State { name: "running" },
        State { name: "stopped" }
    ]
}

Если список содержит один элемент, квадратные скобки можно опустить:

import QtQuick 2.0

Item {
    states: State { name: "running" }
}

Свойство типа список можно указать в объявлении объекта с помощью следующего синтаксиса:

[default] property list<<objectType>> propertyName

И, как и в других объявлениях свойств, присвоение значения свойства можно объединить с объявлением свойства следующим образом:

[default] property list<<objectType>> propertyName: <value>

Следующий пример демонстрирует объявление свойства списка:

import QtQuick 2.0

Rectangle {
    // declaration without initialization
    property list<Rectangle> siblingRects

    // declaration with initialization
    property list<Rectangle> childRects: [
        Rectangle { color: "red" },
        Rectangle { color: "blue"}
    ]
}

Если необходимо объявить свойство для хранения списка значений, которые не обязательно являются значениями QML типа объекта, следует объявить свойство типа var вместо этого.

Сгруппированные свойства

В некоторых случаях свойства содержат логическую группу атрибутов подсвойств. Эти атрибуты подсвойств можно присвоить, используя либо обозначение точек, либо обозначение группы.

Например, тип Text имеет сгруппированное свойство font. В примере ниже первый объект Text инициализирует свои значения font с использованием обозначения точек, а второй — с использованием обозначения группы:

Text {
    //dot notation
    font.pixelSize: 12
    font.b: true
}

Text {
    //group notation
    font { pixelSize: 12; b: true }
}

Сгруппированные типы свойств — это базовые типы, имеющие подсвойства. Некоторые из этих базовых типов предоставляются языком QML, в то время как другие могут использоваться только при импорте модуля Qt Quick. Подробнее см. документацию по базовым типам QML.

Псевдонимы свойств

Псевдонимы свойств — это свойства, которые содержат ссылку на другое свойство. В отличие от обычного определения свойства, которое выделяет новое уникальное хранилище для свойства, псевдоним свойства связывает вновь объявленное свойство (называемое псевдонимирующим свойством) как прямую ссылку на существующее свойство (свойство-оригинал).

Объявление псевдонима свойства похоже на обычное определение свойства, за исключением того, что оно требует ключевого слова alias вместо типа свойства, а правая часть объявления свойства должна быть допустимой ссылкой на псевдоним:

[default] property alias <name>: <alias reference>

В отличие от обычного свойства, псевдоним имеет следующие ограничения:

• Он может ссылаться только на объект или свойство объекта, находящегося в области действия типа, в котором объявлен псевдоним.
• Он не может содержать произвольные выражения JavaScript.
• Он не может ссылаться на объекты, объявленные за пределами области действия его типа.
• Ссылка на псевдоним не является необязательной, в отличие от необязательного значения по умолчанию для обычного свойства; ссылка на псевдоним должна быть указана при первом объявлении псевдонима.
• Он не может ссылаться на сгруппированные свойства; следующий код не будет работать:

  property alias color: rectangle.border.color
  
  Rectangle {
      id: rectangle
  }

  Однако псевдонимы для свойств типа значения работают:

  property alias rectX: object.rectProperty.x
  
  Item {
      id: object
      property rect rectProperty
  }

Например, ниже представлен Button тип со свойством buttonText псевдонима, связанным с объектом text дочернего объекта Text:

// Button.qml
import QtQuick 2.0

Rectangle {
    property alias buttonText: textItem.text

    width: 100; height: 30; color: "yellow"

    Text { id: textItem }
}

Следующий код создаст Button с определённой строкой текста для дочернего объекта Text:

Button { buttonText: "Click Me" }

Здесь изменение buttonText напрямую изменяет значение textItem.text; это не изменяет какое-либо другое значение, которое затем обновляет textItem.text. Если buttonText не являлось псевдонимом, изменение его значения фактически не изменило бы отображаемый текст, так как привязки свойств не являются двунаправленными: значение buttonText изменилось бы, если бы изменилось textItem.text, но не наоборот.

Рассмотрение псевдонимов свойств

Псевдонимы активируются только после полной инициализации компонента. При попытке обратиться к неинициализированному псевдониму генерируется ошибка. Аналогично, псевдонимирование псевдонима свойства также приведет к ошибке.

property alias widgetLabel: label

//will generate an error
//widgetLabel.text: "Initial text"

//will generate an error
//property alias widgetLabelText: widgetLabel.text

Component.onCompleted: widgetLabel.text = "Alias completed Initialization"

Однако при импорте типа QML-объекта с псевдонимом свойства в корневом объекте свойство отображается как обычное свойство Qt и, следовательно, может использоваться в ссылках на псевдонимы.

Возможно, что псевдонимирующее свойство имеет то же имя, что и существующее свойство, фактически перезаписывая существующее свойство. Например, у следующего типа QML есть свойство color псевдоним, имеющее то же имя, что и встроенное свойство Rectangle::color:

Rectangle {
    id: coloredrectangle
    property alias color: bluerectangle.color
    color: "red"

    Rectangle {
        id: bluerectangle
        color: "#1234ff"
    }

    Component.onCompleted: {
        console.log (coloredrectangle.color)    //prints "#1234ff"
        setInternalColor()
        console.log (coloredrectangle.color)    //prints "#111111"
        coloredrectangle.color = "#884646"
        console.log (coloredrectangle.color)    //prints #884646
    }

    //internal function that has access to internal properties
    function setInternalColor() {
        color = "#111111"
    }
}

Любой объект, использующий этот тип и ссылающийся на его свойство color, будет ссылаться на псевдоним, а не на обычное свойство Rectangle::color. Однако внутренне прямоугольник может правильно установить свойство color и ссылаться на фактически определённое свойство, а не на псевдоним.

Свойства по умолчанию

Определение объекта может иметь одно свойство по умолчанию. Свойство по умолчанию — это свойство, которому присваивается значение, если объект объявлен внутри определения другого объекта без объявления его как значения для определённого свойства.

Объявление свойства с необязательным ключевым словом default помечает его как свойство по умолчанию. Например, пусть есть файл MyLabel.qml со свойством по умолчанию someText:

// MyLabel.qml
import QtQuick 2.0

Text {
    default property var someText

    text: "Hello, " + someText.text
}

Значению someText можно присвоить в определении объекта MyLabel следующим образом:

MyLabel {
    Text { text: "world!" }
}

Это имеет точно такой же эффект, как и следующее:

MyLabel {
    someText: Text { text: "world!" }
}

Однако, поскольку свойство someText помечено как свойство по умолчанию, нет необходимости явно назначать объект Text этому свойству.

Вы заметите, что дочерние объекты могут быть добавлены к любому типу, основанному на Item, без явного добавления их к свойству children. Это потому, что свойство по умолчанию для Item — это свойство data , и любые элементы, добавленные в этот список для Item, автоматически добавляются в его список children.

Свойства по умолчанию могут быть полезны для повторного назначения дочерних элементов элемента. Смотрите пример TabWidget, который использует свойство по умолчанию для автоматического повторного назначения дочерних элементов TabWidget в качестве дочерних элементов внутреннего ListView. См. также Расширение QML.

Только для чтения свойства

Объявление объекта может определять свойство только для чтения, используя ключевое слово readonly со следующим синтаксисом:

readonly property <propertyType> <propertyName> : <initialValue>

Свойствам только для чтения обязательно должно быть присвоено значение при инициализации. После инициализации свойства только для чтения его больше нельзя присваивать значение, ни из императивного кода, ни каким-либо другим способом.

Например, код в блоке Component.onCompleted ниже некорректен:

Item {
    readonly property int someNumber: 10

    Component.onCompleted: someNumber = 20  // doesn't work, causes an error
}

Примечание: Свойство только для чтения не может также быть свойством по умолчанию.

Объекты-модификаторы свойств

Свойства могут иметь объекты-модификаторы значений свойств, связанные с ними. Синтаксис объявления экземпляра типа модификатора свойства, связанного с конкретным свойством, следующий:

<PropertyModifierTypeName> on <propertyName> {
    // attributes of the object instance
}

Важно отметить, что приведенный выше синтаксис на самом деле является объявлением объекта, которое создаст объект, который будет действовать на уже существующее свойство.

Некоторые типы модификаторов свойств могут быть применимы только к определенным типам свойств, однако это не проверяется языком. Например, тип NumberAnimation , предоставляемый QtQuick , будет анимировать только числовые свойства (например, int или real). Попытка использовать NumberAnimation с нечисловым свойством не приведет к ошибке, однако нечисловое свойство не будет анимироваться. Поведение типа модификатора свойства при связывании с определённым типом свойства определяется его реализацией.

Атрибуты сигнала

Сигнал — это уведомление от объекта о том, что произошло какое-либо событие: например, изменилось свойство, началась или завершилась анимация или загружено изображение. Тип MouseArea, например, имеет сигнал clicked, который генерируется при нажатии пользователем в области мыши.

Объект может получать уведомление через обработчик сигнала всякий раз, когда генерируется определённый сигнал. Обработчик сигнала объявляется с синтаксисом on<Signal>, где <Signal> — имя сигнала, первая буква которого заглавная. Обработчик сигнала должен быть объявлен в определении объекта, который генерирует сигнал, и обработчик должен содержать блок кода JavaScript, который будет выполняться при вызове обработчика сигнала.

Например, обработчик сигнала onClicked ниже объявлен внутри объекта MouseArea, и вызывается при нажатии на MouseArea, что приводит к выводу сообщения в консоль:

import QtQuick 2.0

Item {
    width: 100; height: 100

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

Определение атрибутов сигнала

Сигнал может быть определён для типа в C++ путём регистрации Q_SIGNAL класса, который затем регистрируется в системе типов QML. Кроме того, пользовательский сигнал для типа объекта может быть определён в объявлении объекта в документе QML с использованием следующего синтаксиса:

signal <signalName>[([<type> <parameter name>[, ...]])]

Попытка объявить два сигнала или метода с одинаковым именем в одном блоке типа — ошибка. Однако новый сигнал может повторно использовать имя существующего сигнала для типа. (Это следует делать с осторожностью, так как существующий сигнал может быть скрыт и станет недоступным.)

Вот три примера объявлений сигналов:

import QtQuick 2.0

Item {
    signal clicked
    signal hovered()
    signal actionPerformed(string action, var actionResult)
}

Если у сигнала нет параметров, скобки «()» необязательны. Если используются параметры, типы параметров должны быть объявлены, как для аргументов string и var для сигнала actionPerformed выше. Допустимые типы параметров совпадают с теми, что перечислены в разделе Определение атрибутов свойства на этой странице.

Для генерации сигнала вызовите его как метод. Все соответствующие обработчики сигналов будут вызваны при генерации сигнала, и обработчики могут использовать определённые имена аргументов сигнала для доступа к соответствующим аргументам.

Сигналы изменения свойства

Типы QML также предоставляют встроенные сигналы изменения свойства, которые генерируются всякий раз, когда значение свойства изменяется, как описано ранее в разделе атрибутов свойства. Смотрите следующую секцию обработчики сигналов изменения свойства для получения дополнительной информации о том, почему эти сигналы полезны и как их использовать.

Атрибуты обработчиков сигналов

Обработчики сигналов — это особый вид атрибутов метода, где реализация метода вызывается движком QML всякий раз, когда генерируется связанный сигнал. Добавление сигнала к определению объекта в QML автоматически добавляет связанный обработчик сигнала к определению объекта, который по умолчанию имеет пустую реализацию. Клиенты могут предоставить реализацию для реализации логики программы.

Рассмотрим следующий SquareButton тип, чьё определение представлено в файле SquareButton.qml как показано ниже, с сигналами activated и deactivated:

// SquareButton.qml
Rectangle {
    id: root

    signal activated(real xPosition, real yPosition)
    signal deactivated

    property int side: 100
    width: side; height: side

    MouseArea {
        anchors.fill: parent
        onPressed: root.activated(mouse.x, mouse.y)
        onReleased: root.deactivated()
    }
}

Эти сигналы могут быть приняты любыми объектами SquareButton в другом файле QML в том же каталоге, где реализации обработчиков сигналов предоставляются клиентом:

// myapplication.qml
SquareButton {
    onActivated: console.log("Activated at " + xPosition + "," + yPosition)
    onDeactivated: console.log("Deactivated!")
}

См. Системы событий сигнала и обработчика для получения дополнительной информации об использовании сигналов.

Обработчики сигналов изменения свойства

Обработчики сигналов для изменения свойств используют синтаксис on<Свойство>Changed, где <Свойство> — это имя свойства с заглавной первой буквой. Например, хотя в документации типа TextInput сигнал textChanged не документирован, он неявно доступен из-за наличия у TextInput свойства text. Таким образом, можно написать обработчик сигнала onTextChanged, который будет вызываться при изменении этого свойства:

import QtQuick 2.0

TextInput {
    text: "Change this!"

    onTextChanged: console.log("Text has changed to:", text)
}

Атрибуты методов

Метод объекта — это функция, которая может быть вызвана для выполнения некоторой обработки или срабатывания других событий. Метод можно подключить к сигналу, чтобы он автоматически вызывался при срабатывании этого сигнала. Подробнее см. в разделе Система событий сигналов и обработчиков.

Определение атрибутов методов

Метод для типа в C++ можно определить, пометив функцию класса тегом Q_INVOKABLE или зарегистрировав её как Q_SLOT класса. В качестве альтернативы, пользовательский метод может быть добавлен к объявлению объекта в документе QML с помощью следующего синтаксиса:

function <functionName>([<parameterName>[, ...]]) { <body> }

Методы могут быть добавлены к типу QML для определения автономных, повторно используемых блоков кода JavaScript. Эти методы могут вызываться как внутри, так и внешними объектами.

В отличие от сигналов, типы параметров методов не обязательно объявлять, так как они по умолчанию имеют тип var.

Попытка объявить два метода или сигнала с одинаковым именем в одном блоке типа является ошибкой. Тем не менее, новый метод может повторно использовать имя существующего метода типа. (Это следует делать с осторожностью, так как существующий метод может быть скрыт и станет недоступным.)

Ниже приведен Rectangle с методом calculateHeight(), который вызывается при присвоении значения height.

import QtQuick 2.0
Rectangle {
    id: rect

    function calculateHeight() {
        return rect.width / 2;
    }

    width: 100
    height: calculateHeight()
}

Если у метода есть параметры, они доступны по имени внутри метода. Ниже, при нажатии на MouseArea вызывается метод moveTo(), который может использовать полученные параметры newX и newY для перепозиционирования текста:

import QtQuick 2.0

Item {
    width: 200; height: 200

    MouseArea {
        anchors.fill: parent
        onClicked: label.moveTo(mouse.x, mouse.y)
    }

    Text {
        id: label

        function moveTo(newX, newY) {
            label.x = newX;
            label.y = newY;
        }

        text: "Move me!"
    }
}

Присоединенные свойства и обработчики сигналов

Присоединенные свойства и присоединённые обработчики сигналов — это механизмы, позволяющие аннотировать объекты дополнительными свойствами или обработчиками сигналов, которые в противном случае недоступны для объекта. В частности, они позволяют объектам обращаться к свойствам или сигналам, которые имеют отношение к конкретному объекту.

Реализация типа QML может создать тип присоединения в C++ с определёнными свойствами и сигналами, как описано в разделе. Экземпляры этого типа можно создавать и присоединять к конкретным объектам во время выполнения, позволяя этим объектам получить доступ к свойствам и сигналам типа присоединения. Они обращаются к ним, добавляя имя типа присоединения к свойствам и соответствующим обработчикам сигналов.

Ссылаясь на присоединенные свойства и обработчики, используйте следующий синтаксис:

<AttachingType>.<propertyName>
<AttachingType>.on<SignalName>

Например, у типа ListView есть присоединённое свойство ListView.isCurrentItem, доступное каждому делегату в ListView. Это можно использовать каждому делегату, чтобы определить, является ли он текущим выбранным элементом в представлении:

import QtQuick 2.0

ListView {
    width: 240; height: 320
    model: 3
    delegate: Rectangle {
        width: 100; height: 30
        color: ListView.isCurrentItem ? "red" : "yellow"
    }
}

В этом случае имя типа присоединения — ListView, а соответствующее свойство — isCurrentItem. Поэтому присоединенное свойство называется ListView.isCurrentItem.

Присоединенный обработчик сигнала обозначается аналогичным образом. Например, присоединённый обработчик сигнала Component.onCompleted часто используется для выполнения некоторого кода JavaScript, когда процесс создания компонента завершен. В примере ниже, после того как ListModel будет полностью создан, его обработчик сигнала Component.onCompleted автоматически вызовет заполнение модели:

import QtQuick 2.0

ListView {
    width: 240; height: 320
    model: ListModel {
        id: listModel
        Component.onCompleted: {
            for (var i = 0; i < 10; i++)
                listModel.append({"Name": "Item " + i})
        }
    }
    delegate: Text { text: index }
}

Поскольку имя типа присоединения — Component, а у этого типа есть сигнал completed, присоединённый обработчик сигнала называется Component.onCompleted.

Примечание об обращении к присоединённым свойствам и обработчикам сигналов

Частая ошибка — считать, что присоединенные свойства и обработчики сигналов напрямую доступны из дочерних элементов объекта, к которому эти атрибуты присоединены. Это не так. Экземпляр типа присоединения прикреплен только к конкретным объектам, а не к объекту и всем его дочерним элементам.

Например, ниже приведена изменённая версия предыдущего примера с присоединёнными свойствами. На этот раз делегат — Item, а цветной Rectangle — дочерний элемент этого элемента:

import QtQuick 2.0

ListView {
    width: 240; height: 320
    model: 3
    delegate: Item {
        width: 100; height: 30

        Rectangle {
            width: 100; height: 30
            color: ListView.isCurrentItem ? "red" : "yellow"    // WRONG! This won't work.
        }
    }
}

Это не работает как ожидалось, потому что ListView.isCurrentItem присоединён только к корневому объекту делегата, а не к его дочерним элементам. Поскольку Rectangle является дочерним элементом делегата, а не самим делегатом, он не может получить доступ к присоединённому свойству isCurrentItem как ListView.isCurrentItem.

Поэтому вместо этого прямоугольник должен получить доступ к isCurrentItem через корневой делегат:

ListView {
    //....
    delegate: Item {
        id: delegateItem
        width: 100; height: 30

        Rectangle {
            width: 100; height: 30
            color: delegateItem.ListView.isCurrentItem ? "red" : "yellow"   // correct
        }
    }
}

Теперь delegateItem.ListView.isCurrentItem правильно ссылается на присоединённое свойство isCurrentItem делегата.