Repeater QML Type

Instancie un certain nombre de composants basés sur des éléments à l'aide d'un modèle fourni. Plus d'informations...

• 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 est utilisé pour créer un grand nombre d'éléments similaires. Comme les autres types de vues, un Repeater possède un model et un 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 entouré d'un type de positionneur tel que Row ou Column pour 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 à l'intérieur d'un élément Row:

import QtQuick

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

Le site model d'un Repeater peut être n'importe lequel des modèles de données pris en charge. En outre, comme les délégués d'autres vues, le délégué d'un Repeater peut accéder à son index dans le Repeater, ainsi qu'aux données de modèle pertinentes pour le délégué. Pour plus de détails, voir la documentation sur la propriété delegate.

Les éléments instanciés par le répéteur sont insérés, dans l'ordre, en tant qu'enfants du parent du répéteur. L'insertion commence immédiatement après la position du répéteur dans la liste d'empilement de son parent. Cela permet d'utiliser un Repeater à l'intérieur d'une mise en page. Par exemple, les éléments suivants du répéteur 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" }
}

Éléments à prendre en compte lors de l'utilisation de Repeater

Le type Repeater crée tous ses éléments délégués lors de la première création du Repeater. Cela peut s'avérer inefficace s'il y a un grand nombre d'éléments délégués et que tous les éléments ne doivent pas être visibles en même temps. Si c'est le cas, envisagez d'utiliser d'autres types de vues comme ListView (qui ne crée des éléments délégués que lorsqu'ils sont affichés par défilement) ou utilisez les méthodes Dynamic Object Creation pour créer des éléments au fur et à mesure qu'ils sont nécessaires.

Notez également que Repeater est basé sur 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 dans le model.

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

• Lorsque 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 modifiée par la suite.
• Si le Repeater ne fait pas partie d'une hiérarchie visuelle complète, 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 apportées à model, le signal itemRemoved() est émis pour chacun d'entre eux et la propriété count est modifiée 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 la propriété 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é dans le 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 le site model est une liste de chaînes ou d'objets, le délégué est également exposé à une propriété modelData en lecture seule qui contient les données de la chaîne ou de l'objet. Par exemple :

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

Si model est un objet de modèle (tel que ListModel), le délégué peut accéder à tous les rôles de modèle en tant que 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 les modèles de données QML.

delegateModelAccess : enumeration [since 6.10]

Cette propriété détermine comment 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 aussi Modèles et vues dans Qt Quick#ChangingModel Data.

model : var

Le modèle fournissant les données pour le 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 qui indique 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 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 à 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 auquel l'élément a été inséré dans le répéteur et le paramètre item contient le Item qui a été ajouté.

itemRemoved(int index, Item item)

Ce signal est émis lorsqu'un élément est retiré du répéteur. Le paramètre index contient l'index auquel l'élément a été retiré du répéteur, et le paramètre item contient le Item qui a été retiré.

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 de temps après le traitement du signal.

Documentation de la méthode

Item itemAt(index)

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