Атрибуты объектов 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 и не может ссылаться на объекты, объявленные за пределами области видимости своего типа. Также обратите внимание, что ссылка на псевдоним не является необязательной, в отличие от необязательного значения по умолчанию для обычного свойства; ссылка на псевдоним должна быть предоставлена при первом объявлении псевдонима.

Например, ниже приведен 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)
        onRelased: 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++ может быть определен путем маркировки функции класса, которая затем регистрируется в системе типов QML с помощью 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 делегата.