Repeater QML Type

Instancie plusieurs composants de type « Item » à partir d'un modèle fourni. En savoir plus...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• count : int
• delegate : Component
• delegateModelAccess : enumeration (since 6.10)
• model : var

Signaux

• itemAdded(int index, Item item)
• itemRemoved(int index, Item item)

Méthodes

• Item itemAt(index)

Description détaillée

Le type Repeater sert à créer un grand nombre d'éléments similaires. À l'instar des autres types de vue, un Repeater dispose d'un délégué de création ( model ) et d'un délégué de mise en place ( delegate) : pour chaque entrée du modèle, le délégué est instancié dans un contexte alimenté par les données du modèle. Un élément « Repeater » est généralement encapsulé dans un type de positionneur tel que « Row » ou « Column » afin de positionner visuellement les multiples éléments délégués créés par le « Repeater ».

Le Repeater suivant crée trois instances d’un élément « Rectangle » au sein d’un « Row » :

import QtQuick

Row {
    Repeater {
        model: 3
        Rectangle {
            width: 100; height: 40
            border.width: 1
            color: "yellow"
        }
    }
}

L’ model d’un Repeater peut être n’importe lequel des modèles de données pris en charge. De plus, à l’instar des délégués d’autres vues, un délégué de Repeater peut accéder à son index au sein du Repeater, ainsi qu’aux données du modèle pertinentes pour le délégué. Consultez la documentation relative à la propriété delegate pour plus de détails.

Les éléments instanciés par le Repeater sont insérés, dans l’ordre, en tant qu’enfants de l’élément parent du Repeater. L'insertion commence immédiatement après la position du Repeater dans la liste d'empilement de son parent. Cela permet d'utiliser un Repeater au sein d'une mise en page. Par exemple, les éléments du Repeater suivant sont empilés entre un rectangle rouge et un rectangle bleu :

Row {
    Rectangle { width: 10; height: 20; color: "red" }
    Repeater {
        model: 10
        Rectangle { width: 20; height: 20; radius: 10; color: "green" }
    }
    Rectangle { width: 10; height: 20; color: "blue" }
}

Considérations relatives à l’utilisation du Repeater

Le type « Repeater » crée tous ses éléments délégués lors de sa création initiale. Cela peut s’avérer inefficace s’il existe un grand nombre d’éléments délégués et que tous ne doivent pas nécessairement être visibles en même temps. Si tel est le cas, envisagez d’utiliser d’autres types de vue, tels que ` ListView ` (qui ne crée les éléments délégués que lorsqu’ils apparaissent à l’écran lors du défilement), ou utilisez les méthodes ` Dynamic Object Creation ` pour créer les éléments au fur et à mesure des besoins.

Notez également que Repeater repose sur le principe de l’ Item et ne peut répéter que des objets dérivés de Item. Par exemple, il ne peut pas être utilisé pour répéter des QtObjects :

// bad code:
Item {
    // Can't repeat QtObject as it doesn't derive from Item.
    Repeater {
        model: 10
        QtObject {}
    }
}

Documentation sur les propriétés

count : int [read-only]

Cette propriété contient le nombre d'éléments présents dans l'model.

La valeur de ` count ` ne correspond pas toujours au nombre d'delegates s instanciés ; utilisez ` itemAt()` pour vérifier si un délégué à un index donné existe. Cette méthode renvoie ` null ` si le délégué n'est pas instancié.

• Pendant que le Repeater est en train d’instancier des délégués (au démarrage ou à la suite de modifications de model ), le signal itemAdded est émis pour chaque délégué créé, et la propriété count est mise à jour par la suite.
• Si le Repeater ne fait pas partie d’une hiérarchie visuelle complète, la propriété ` count ` reflète la taille du modèle, mais aucun délégué n’est créé.
• Si le Repeater détruit des délégués en raison de modifications de model, le signal itemRemoved() est émis pour chacun d’entre eux, et la propriété count est mise à jour par la suite.
• Si le Repeater est retiré de la hiérarchie visuelle (par exemple en définissant ` parent = null`), les délégués sont détruits, le signal ` itemRemoved()` est émis pour chacun d’entre eux, mais ` count ` ne change pas.

Voir également itemAt(), itemAdded() et itemRemoved().

delegate : Component [default]

Le délégué fournit un modèle définissant chaque élément instancié par le répéteur.

Les délégués sont exposés à une propriété en lecture seule ` index ` qui indique l'index du délégué au sein du répéteur. Par exemple, le délégué ` Text ` suivant affiche l'index de chaque élément répété :

Column {
    Repeater {
        model: 10
        Text {
            required property int index
            text: "I'm item " + index
        }
    }
}

Si l’ model est une liste de chaînes ou une liste d’objets, le délégué dispose également d’une propriété en lecture seule modelData qui contient les données de chaîne ou d’objet. Par exemple :

Column {
    Repeater {
        model: ["apples", "oranges", "pears"]
        Text {
            required property string modelData
            text: "Data: " + modelData
        }
    }
}

Si l’ model est un objet modèle (tel qu’un ListModel), le délégué peut accéder à tous les rôles du modèle sous forme de propriétés nommées, de la même manière que les délégués le font pour les classes de vue telles que ListView.

Voir également Modèles de données QML.

delegateModelAccess : enumeration [since 6.10]

Cette propriété détermine la manière dont les délégués peuvent accéder au modèle.

La valeur par défaut est ` DelegateModel.Qt5ReadWrite`.

Cette propriété a été introduite dans Qt 6.10.

Voir également Modèles et vues dans Qt Quick#Modification des données du modèle.

model : var

Le modèle fournissant les données au répéteur.

Cette propriété peut être définie sur n'importe lequel des modèles de données pris en charge :

• Un nombre indiquant le nombre de délégués à créer par le répéteur
• Un modèle (par exemple, un élément « ListModel » ou une sous-classe de « QAbstractItemModel »)
• Une liste de chaînes de caractères
• Une liste d’objets

Le type de modèle influe sur les propriétés exposées à l'delegate.

Voir également Modèles de données.

Documentation sur les signaux

itemAdded(int index, Item item)

Ce signal est émis lorsqu'un élément est ajouté au répéteur. Le paramètre ` index ` contient l'index à l'emplacement duquel l'élément a été inséré dans le répéteur, et le paramètre ` item ` contient l'Item qui a été ajoutée.

itemRemoved(int index, Item item)

Ce signal est émis lorsqu'un élément est supprimé du répéteur. Le paramètre « index » contient l'index à partir duquel l'élément a été supprimé du répéteur, et le paramètre « item » contient l'Item qui a été supprimée.

Ne conservez pas de référence à item s’il a été créé par ce répéteur, car dans ce cas, il sera supprimé peu après le traitement du signal.

Documentation de la méthode

Item itemAt(index)

Renvoie l'Item qui a été créé à l'adresse index, ou null si aucun élément n'existe à l'adresse index.