QAbstractItemModel Class

Documentation des fonctions membres

[explicit] QAbstractItemModel::QAbstractItemModel(QObject *parent = nullptr)

Crée un modèle d'élément abstrait à partir de l'parent on fournie.

[virtual noexcept] QAbstractItemModel::~QAbstractItemModel()

Supprime le modèle d'élément abstrait.

[protected] void QAbstractItemModel::beginInsertColumns(const QModelIndex &parent, int first, int last)

Lance une opération d'insertion de colonne.

Lorsque vous réimplémentez la méthode insertColumns() dans une sous-classe, vous devez appeler cette fonction avant d'insérer des données dans le magasin de données sous-jacent du modèle.

L'index ` parent ` correspond au parent dans lequel les nouvelles colonnes sont insérées ; ` first ` et ` last ` sont les numéros que porteront les nouvelles colonnes après leur insertion.

	Spécifiez les numéros de la première et de la dernière colonne de la plage de colonnes que vous souhaitez insérer dans un élément d’un modèle. Par exemple, comme le montre le schéma, nous insérons trois colonnes avant la colonne 4 ; ainsi, first vaut 4 et last vaut 6 : beginInsertColumns(parent, 4, 6); Cela insère les trois nouvelles colonnes en tant que colonnes 4, 5 et 6.
	Pour ajouter des colonnes, insérez-les après la dernière colonne. Par exemple, comme le montre le schéma, nous ajoutons trois colonnes à un ensemble de six colonnes existantes (se terminant par la colonne 5) ; ainsi, first vaut 6 et last vaut 8 : beginInsertColumns(parent, 6, 8); Cela ajoute les deux nouvelles colonnes en tant que colonnes 6, 7 et 8.

Voir également endInsertColumns().

[protected] void QAbstractItemModel::beginInsertRows(const QModelIndex &parent, int first, int last)

Lance une opération d'insertion de ligne.

Lorsque vous réimplémentez la méthode ` insertRows()` dans une sous-classe, vous devez appeler cette fonction avant d’insérer des données dans le magasin de données sous-jacent du modèle.

L'index parent correspond au parent dans lequel les nouvelles lignes sont insérées ; first et last sont les numéros de ligne que les nouvelles lignes porteront après leur insertion.

	Spécifiez les numéros de la première et de la dernière ligne de la plage de lignes que vous souhaitez insérer dans un élément d’un modèle. Par exemple, comme le montre le schéma, nous insérons trois lignes avant la ligne 2 ; ainsi, first vaut 2 et last vaut 4 : beginInsertRows(parent, 2, 4); Cela insère les trois nouvelles lignes en tant que lignes 2, 3 et 4.
	Pour ajouter des lignes, insérez-les après la dernière ligne. Par exemple, comme le montre le schéma, nous ajoutons deux lignes à une collection de 4 lignes existantes (se terminant par la ligne 3) ; ainsi, first vaut 4 et last vaut 5 : beginInsertRows(parent, 4, 5); Cela ajoute les deux nouvelles lignes en tant que lignes 4 et 5.

Voir également endInsertRows().

[protected] bool QAbstractItemModel::beginMoveColumns(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)

Lance une opération de déplacement de colonnes.

Lors de la réimplémentation d’une sous-classe, cette méthode simplifie le déplacement d’entités dans votre modèle. Elle est chargée de déplacer les index persistants dans le modèle, ce que vous devriez sinon effectuer vous-même. L’utilisation de `beginMoveColumns` et ` endMoveColumns ` constitue une alternative à l’émission directe de ` layoutAboutToBeChanged ` et ` layoutChanged ` avec ` changePersistentIndex`.

L’index sourceParent correspond au parent à partir duquel les colonnes sont déplacées ; sourceFirst et sourceLast sont respectivement le premier et le dernier numéro des colonnes à déplacer. L’index destinationParent correspond au parent vers lequel ces colonnes sont déplacées. destinationChild est la colonne vers laquelle les colonnes seront déplacées. Autrement dit, l’index de la colonne sourceFirst dans sourceParent deviendra la colonne destinationChild dans destinationParent, suivi de toutes les autres colonnes jusqu’à sourceLast.

En revanche, lorsque l’on déplace des colonnes vers le bas au sein d’un même parent (sourceParent et destinationParent sont égaux), les colonnes seront placées avant l’index destinationChild. Autrement dit, si vous souhaitez déplacer les colonnes 0 et 1 pour qu’elles deviennent les colonnes 1 et 2, destinationChild doit être égal à 3. Dans ce cas, le nouvel index de la colonne source i (qui se situe entre sourceFirst et sourceLast) est égal à (destinationChild-sourceLast-1+i).

Notez que si sourceParent et destinationParent sont identiques, vous devez vous assurer que destinationChild ne se trouve pas dans l’intervalle compris entre sourceFirst et sourceLast + 1. Vous devez également veiller à ne pas tenter de déplacer une colonne vers l’un de ses propres enfants ou ancêtres. Cette méthode renvoie false si l’une ou l’autre de ces conditions est vraie, auquel cas vous devez interrompre votre opération de déplacement.

Voir également endMoveColumns().

[protected] bool QAbstractItemModel::beginMoveRows(const QModelIndex &sourceParent, int sourceFirst, int sourceLast, const QModelIndex &destinationParent, int destinationChild)

Lance une opération de déplacement de lignes.

Lors de la réimplémentation d’une sous-classe, cette méthode simplifie le déplacement d’entités dans votre modèle. Elle est chargée de déplacer les index persistants dans le modèle, ce que vous devriez sinon effectuer vous-même. L’utilisation de `beginMoveRows` et ` endMoveRows ` constitue une alternative à l’émission directe de ` layoutAboutToBeChanged ` et ` layoutChanged `, ainsi que de ` changePersistentIndex`.

L’index sourceParent correspond au parent à partir duquel les lignes sont déplacées ; sourceFirst et sourceLast sont respectivement les numéros de la première et de la dernière ligne à déplacer. L’index destinationParent correspond au parent vers lequel ces lignes sont déplacées. Le paramètre destinationChild désigne la ligne vers laquelle les lignes seront déplacées. Autrement dit, l’index de la ligne sourceFirst dans sourceParent deviendra la ligne destinationChild dans destinationParent, suivie de toutes les autres lignes jusqu’à sourceLast.

En revanche, lorsque l’on déplace des lignes vers le bas au sein du même parent (sourceParent et destinationParent sont identiques), les lignes seront placées avant l’index destinationChild. Autrement dit, si vous souhaitez déplacer les lignes 0 et 1 pour qu’elles deviennent les lignes 1 et 2, destinationChild doit être égal à 3. Dans ce cas, le nouvel index de la ligne source i (qui se trouve entre sourceFirst et sourceLast) est égal à (destinationChild-sourceLast-1+i).

Notez que si sourceParent et destinationParent sont identiques, vous devez vous assurer que l’ destinationChild ne se trouve pas dans l’intervalle compris entre sourceFirst et sourceLast + 1. Vous devez également vous assurer de ne pas tenter de déplacer une ligne vers l’un de ses propres enfants ou ancêtres. Cette méthode renvoie false si l’une ou l’autre de ces conditions est vraie, auquel cas vous devez interrompre votre opération de déplacement.

	Spécifiez les numéros de la première et de la dernière ligne de la plage de lignes du parent source que vous souhaitez déplacer dans le modèle. Spécifiez également la ligne du parent de destination vers laquelle déplacer cette plage. Par exemple, comme le montre le schéma, nous déplaçons trois lignes de la ligne 2 à la ligne 4 dans la source ; ainsi, ` sourceFirst ` vaut 2 et ` sourceLast ` vaut 4. Nous déplaçons ces éléments au-dessus de la ligne 2 dans la destination ; ainsi, ` destinationChild ` vaut 2. beginMoveRows(sourceParent, 2, 4, destinationParent, 2); Cela déplace les trois lignes 2, 3 et 4 de la source, qui deviennent respectivement 2, 3 et 4 dans la destination. Les autres éléments frères concernés sont déplacés en conséquence.
	Pour ajouter des lignes à un autre parent, déplacez-les après la dernière ligne. Par exemple, comme le montre le schéma, nous déplaçons trois lignes vers un ensemble de 6 lignes existantes (se terminant à la ligne 5) ; l’ destinationChild t donc 6 : beginMoveRows(sourceParent, 2, 4, destinationParent, 6); Cela déplace les lignes cibles à la fin de l'élément parent cible en tant que lignes 6, 7 et 8.
	Pour déplacer des lignes au sein d’un même élément parent, précisez la ligne vers laquelle les déplacer. Par exemple, comme le montre le schéma, nous déplaçons un élément de la ligne 2 vers la ligne 0 ; ainsi, sourceFirst et sourceLast prennent la valeur 2, tandis que destinationChild prend la valeur 0. beginMoveRows(parent, 2, 2, parent, 0); Notez que d'autres lignes peuvent être déplacées en conséquence. Notez également que lorsque vous déplacez des éléments au sein d'un même parent, vous ne devez pas tenter de déplacements invalides ou sans effet. Dans l’exemple ci-dessus, l’élément 2 se trouve à la ligne 2 avant le déplacement ; il ne peut donc pas être déplacé vers la ligne 2 (où il se trouve déjà) ni vers la ligne 3 (opération sans effet, car la ligne 3 correspond à une position au-dessus de la ligne 3, où il se trouve déjà).
	Pour déplacer des lignes au sein d’un même élément parent, spécifiez la ligne vers laquelle vous souhaitez les déplacer. Par exemple, comme le montre le schéma, nous déplaçons un élément de la ligne 2 vers la ligne 4 ; ainsi, sourceFirst et sourceLast sont 2 et destinationChild est 4. beginMoveRows(parent, 2, 2, parent, 4); Notez que d'autres lignes peuvent être déplacées en conséquence.

Voir également endMoveRows().

[protected] void QAbstractItemModel::beginRemoveColumns(const QModelIndex &parent, int first, int last)

Lance une opération de suppression de colonne.

Lorsque vous réimplémentez la méthode removeColumns() dans une sous-classe, vous devez appeler cette fonction avant de supprimer des données du magasin de données sous-jacent du modèle.

L'index parent correspond au parent à partir duquel les nouvelles colonnes sont supprimées ; first et last sont les numéros de la première et de la dernière colonne à supprimer.

Spécifiez les numéros de la première et de la dernière colonne de la plage de colonnes que vous souhaitez supprimer d’un élément d’un modèle. Par exemple, comme le montre le schéma, nous supprimons les trois colonnes comprises entre la colonne 4 et la colonne 6 ; ainsi, first vaut 4 et last vaut 6 : beginRemoveColumns(parent, 4, 6);

Voir également endRemoveColumns().

[protected] void QAbstractItemModel::beginRemoveRows(const QModelIndex &parent, int first, int last)

Lance une opération de suppression de ligne.

Lorsque vous réimplémentez la méthode removeRows() dans une sous-classe, vous devez appeler cette fonction avant de supprimer des données du magasin de données sous-jacent du modèle.

L'index parent correspond au parent à partir duquel les nouvelles lignes sont supprimées ; first et last sont les numéros des lignes à supprimer.

Spécifiez les numéros de la première et de la dernière ligne de la plage de lignes que vous souhaitez supprimer d'un élément d'un modèle. Par exemple, comme le montre le schéma, nous supprimons les deux lignes comprises entre la ligne 2 et la ligne 3 ; first est donc 2 et last est 3 : beginRemoveRows(parent, 2, 3);

Voir également endRemoveRows().

[protected] void QAbstractItemModel::beginResetModel()

Lance une opération de réinitialisation du modèle.

Une opération de réinitialisation ramène le modèle à son état actuel dans toutes les vues associées.

Lorsqu’un modèle est réinitialisé, cela signifie que toutes les données précédemment renvoyées par le modèle ne sont désormais plus valides et doivent être récupérées à nouveau. Cela signifie également que l’élément actuel et tous les éléments sélectionnés ne seront plus valides.

Lorsqu’un modèle modifie radicalement ses données, il est parfois plus simple d’appeler cette fonction plutôt que d’émettre un événement ` dataChanged()` pour informer les autres composants que la source de données sous-jacente, ou sa structure, a changé.

Vous devez appeler cette fonction avant de réinitialiser toute structure de données interne de votre modèle ou de votre modèle proxy.

Cette fonction émet le signal ` modelAboutToBeReset()`.

Voir également modelAboutToBeReset(), modelReset() et endResetModel().

[virtual] QModelIndex QAbstractItemModel::buddy(const QModelIndex &index) const

Renvoie un index de modèle correspondant au « buddy » de l'élément représenté par index. Lorsque l'utilisateur souhaite modifier un élément, la vue appelle cette fonction pour vérifier si ce n'est pas plutôt un autre élément du modèle qui doit être modifié. La vue construit ensuite un délégué à partir de l'index de modèle renvoyé par l'élément « buddy ».

L'implémentation par défaut de cette fonction considère que chaque élément est son propre « buddy ».

[virtual] bool QAbstractItemModel::canDropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) const

Renvoie true si un modèle peut accepter la suppression de l'data. Cette implémentation par défaut vérifie uniquement si data comporte au moins un format dans la liste de mimeTypes() et si action figure parmi les supportedDropActions() du modèle.

Réimplémentez cette fonction dans votre modèle personnalisé si vous souhaitez vérifier si l’ data peut être déposé à l’adresse row, column, parent avec action. Si vous n’avez pas besoin de ce test, il n’est pas nécessaire de réimplémenter cette fonction.

Voir également dropMimeData() et Utilisation du glisser-déposer avec les vues d'éléments.

[virtual invokable] bool QAbstractItemModel::canFetchMore(const QModelIndex &parent) const

Renvoie true s’il y a davantage de données disponibles pour parent; sinon, renvoie false.

L'implémentation par défaut renvoie toujours false.

Si canFetchMore() renvoie true, la fonction fetchMore() doit être appelée. C'est par exemple le comportement de QAbstractItemView.

Voir également fetchMore().

[protected] void QAbstractItemModel::changePersistentIndex(const QModelIndex &from, const QModelIndex &to)

Remplace l’ QPersistentModelIndex, dont l’index de modèle correspond à l’index de modèle from, par l’index de modèle to.

Si aucun index de modèle persistant correspondant à l’index de modèle from spécifié n’a été trouvé, aucune modification n’est effectuée.

Voir également persistentIndexList() et changePersistentIndexList().

[protected] void QAbstractItemModel::changePersistentIndexList(const QModelIndexList &from, const QModelIndexList &to)

Remplace les {QPersistentModelIndex} correspondant aux index de la liste d'index de modèle indiquée à l'adresse from par ceux de la liste d'index de modèle indiquée à l'adresse to.

Si aucun index de modèle persistant ne correspond aux index de la liste d’index de modèle fournie par from, aucune modification n’est effectuée.

Voir également persistentIndexList() et changePersistentIndex().

bool QAbstractItemModel::checkIndex(const QModelIndex &index, QAbstractItemModel::CheckIndexOptions options = CheckIndexOption::NoOption) const

Cette fonction vérifie si index est un index de modèle valide pour ce modèle. Un index de modèle valide est soit un index de modèle non valide, soit un index de modèle valide pour lequel toutes les conditions suivantes sont remplies :

• le modèle de l'index est this;
• la ligne de l’index est supérieure ou égale à zéro ;
• la ligne de l'index est inférieure au nombre de lignes de son parent ;
• la colonne de l’index est supérieure ou égale à zéro ;
• la colonne de l’index est inférieure au nombre de colonnes de son parent.

L’argument ` options ` peut modifier certaines de ces vérifications. Si ` options ` contient ` IndexIsValid`, alors ` index ` doit être un index valide ; cela est utile lors de la réimplémentation de fonctions telles que ` data()` ou ` setData()`, qui attendent des index valides.

Si options contient DoNotUseParent, les vérifications qui appelleraient parent() sont omises ; cela permet d’appeler cette fonction depuis une réimplémentation de parent() (sinon, cela entraînerait une récursion sans fin et un plantage).

Si options ne contient pas DoNotUseParent, mais contient ParentIsInvalid, une vérification supplémentaire est effectuée : on vérifie que l’index parent n’est pas valide. Cela s’avère utile lors de l’implémentation de modèles plats tels que des listes ou des tableaux, où aucun index de modèle ne devrait avoir d’index parent valide.

Cette fonction renvoie « true » si toutes les vérifications ont abouti, et « false » dans le cas contraire. Cela permet d’utiliser la fonction dans ` Q_ASSERT ` et d’autres mécanismes de débogage similaires. Si une vérification échoue, un message d’avertissement sera affiché dans la catégorie de journalisation ` qt.core.qabstractitemmodel.checkindex `, contenant des informations pouvant s’avérer utiles pour le débogage de l’échec.

Voir également QModelIndex.

[virtual, since 6.0] bool QAbstractItemModel::clearItemData(const QModelIndex &index)

Supprime les données stockées dans tous les rôles associés à l’ index donné. Renvoie true en cas de succès ; sinon, renvoie false. Le signal dataChanged() doit être émis si les données ont été supprimées avec succès. L’implémentation de la classe de base renvoie false

Cette fonction a été introduite dans Qt 6.0.

Voir également data(), itemData(), setData() et setItemData().

[pure virtual invokable] int QAbstractItemModel::columnCount(const QModelIndex &parent = QModelIndex()) const

Renvoie le nombre de colonnes des enfants de l'parent donné.

Dans la plupart des sous-classes, le nombre de colonnes est indépendant de l'parent.

Par exemple :

int MyModel::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    return 3;
}

Voir également rowCount().

[private signal] void QAbstractItemModel::columnsAboutToBeInserted(const QModelIndex &parent, int first, int last)

Ce signal est émis juste avant l'insertion de colonnes dans le modèle. Les nouveaux éléments seront positionnés entre first et last inclus, sous l'élément parent spécifié.

Voir également insertColumns() et beginInsertColumns().

[private signal] void QAbstractItemModel::columnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)

Ce signal est émis juste avant le déplacement des colonnes au sein du modèle. Les éléments qui seront déplacés sont ceux situés entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné. Ils seront déplacés vers destinationParent à partir de la colonne destinationColumn.

Remarque : les composants connectés à ce signal l'utilisent pour s'adapter aux changements de dimensions du modèle. Il ne peut être émis que par l'implémentation de ` QAbstractItemModel ` et ne peut pas être émis explicitement dans le code d'une sous-classe.

Voir également beginMoveRows().

[private signal] void QAbstractItemModel::columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last)

Ce signal est émis juste avant que les colonnes ne soient supprimées du modèle. Les éléments à supprimer sont ceux situés entre first et last inclus, sous l'élément parent donné.

Voir également removeColumns() et beginRemoveColumns().

[private signal] void QAbstractItemModel::columnsInserted(const QModelIndex &parent, int first, int last)

Ce signal est émis une fois que des colonnes ont été insérées dans le modèle. Les nouveaux éléments sont ceux situés entre first et last inclus, sous l'élément parent donné.

Voir également insertColumns() et beginInsertColumns().

[private signal] void QAbstractItemModel::columnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationColumn)

Ce signal est émis après le déplacement de colonnes au sein du modèle. Les éléments situés entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné, ont été déplacés vers destinationParent à partir de la colonne destinationColumn.

Remarque : les composants connectés à ce signal l'utilisent pour s'adapter aux changements de dimensions du modèle. Il ne peut être émis que par l'implémentation de QAbstractItemModel et ne peut pas être émis explicitement dans le code d'une sous-classe.

Voir également beginMoveRows().

[private signal] void QAbstractItemModel::columnsRemoved(const QModelIndex &parent, int first, int last)

Ce signal est émis une fois que des colonnes ont été supprimées du modèle. Les éléments supprimés sont ceux situés entre first et last inclus, sous l'élément parent donné.

Voir également ` removeColumns()` et ` beginRemoveColumns()`.

Compare l'left QVariant avec l'right QVariant , et renvoie l'ordre sous la forme d'un weak ordering.

Si l’ QVariant est comparée en tant que chaîne de caractères, l’objet collator facultatif est alors utilisé pour la comparaison locale-aware et case-sensitive. Si aucun collateur n’est fourni, les chaînes sont alors comparées exclusivement sur la base des valeurs Unicode numériques des caractères. Cette méthode est rapide, mais ne correspond souvent pas à ce qu’un utilisateur attend d’une interface utilisateur.

Cette fonction est adaptée aux implémentations de ` QAbstractItemModel::sort()` (), fournissant un ordre faible même pour les valeurs variantes qui ne peuvent pas être comparées, c’est-à-dire lorsque ` QVariant::compare ` renverrait ` unordered`. Cela permet de l’utiliser en toute sécurité dans ` std::sort ` et ` std::stable_sort`, qui nécessitent des données pouvant être classées.

void Model::sort(int column, Qt::SortOrder sortOrder)
{
    // Model operates on a QList<QVariant> data
    std::sort(data.begin(), data.end(), [=](const QVariant &lhs, const Variant &rhs){
        const auto ordering = compareData(lhs, rhs);
        return sortOrder == Qt::AscendingOrder ? sortOrder < 0 : sortOrder > 0;
    });
}

Si l’ left QVariant contient une chaîne de caractères, les variantes sont alors comparées as strings, en utilisant l’option collator si nécessaire.

Sinon, l’implémentation compare left et right à l’aide de QVariant::compare(), qui ne peut fournir qu’un ordonnancement partiel. Si la comparaison produit un résultat unordered, et que les meta type de left et right ne sont pas identiques, la fonction tente alors de convert les variantes vers un type commun, puis la comparaison est réessayée.

Si cela produit encore un résultat « unordered », la représentation sous forme de chaîne de caractères des deux variantes est alors comparée. Cela peut amener à comparer deux chaînes vides, qui sont {Qt::weak_ordering::}{équivalentes}.

Invalid variants sont toujours considérées comme supérieures aux variantes contenant une valeur valide.

Ces fonctions ont été introduites dans Qt 6.12.

Voir également « comparaison à trois voies », ` sort()`, ` QVariant::compare` et ` QSortFilterProxyModel`.

[protected] QModelIndex QAbstractItemModel::createIndex(int row, int column, const void *ptr = nullptr) const

Crée un index de modèle pour les objets ` row ` et ` column ` indiqués, avec le pointeur interne ` ptr`.

Lorsqu’on utilise un QSortFilterProxyModel, ses index possèdent leur propre pointeur interne. Il n’est pas recommandé d’accéder à ce pointeur interne en dehors du modèle. Utilisez plutôt la fonction data().

Cette fonction fournit une interface cohérente que les sous-classes du modèle doivent utiliser pour créer des index de modèle.

[protected] QModelIndex QAbstractItemModel::createIndex(int row, int column, quintptr id) const

Crée un index de modèle pour les éléments row et column, avec l'identifiant interne id.

Cette fonction fournit une interface cohérente que les sous-classes de modèle doivent utiliser pour créer des index de modèle.

Voir également QModelIndex::internalId().

[pure virtual invokable] QVariant QAbstractItemModel::data(const QModelIndex &index, int role = Qt::DisplayRole) const

Renvoie les données stockées sous l'role donné pour l'élément référencé par l'index.

Voir également Qt::ItemDataRole, setData() et headerData().

[signal] void QAbstractItemModel::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList<int> &roles = QList<int>())

Ce signal est émis chaque fois que les données d'un élément existant changent.

Si les éléments ont le même parent, ceux qui sont concernés sont ceux compris entre ` topLeft ` et ` bottomRight `, inclus. Si les éléments n’ont pas le même parent, le comportement est indéfini.

Lors de la réimplémentation de la fonction setData(), ce signal doit être émis explicitement.

L’argument facultatif ` roles ` peut être utilisé pour préciser quels rôles de données ont effectivement été modifiés. Un vecteur vide dans l’argument `roles` signifie que tous les rôles doivent être considérés comme modifiés. L’ordre des éléments dans l’argument `roles` n’a aucune importance.

Voir également headerDataChanged(), setData() et layoutChanged().

[virtual] bool QAbstractItemModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)

Gère l'objet ` data ` fourni par une opération de glisser-déposer qui s'est terminée par l'action` indiquée.

Renvoie ` true ` si les données et l'action ont été gérées par le modèle ; sinon, renvoie ` false`.

Les paramètres row, column et parent indiquent l’emplacement d’un élément dans le modèle où l’opération s’est terminée. Il incombe au modèle de mener à bien l’action à l’emplacement correct.

Par exemple, une action de glisser-déposer sur un élément situé dans un QTreeView peut entraîner l’insertion de nouveaux éléments soit en tant qu’enfants de l’élément spécifié par row, column et parent, soit en tant que frères et sœurs de cet élément.

parentLorsque row et column sont égaux à -1, cela signifie que les données déposées doivent être considérées comme ayant été déposées directement sur parent. En général, cela implique d’ajouter les données en tant qu’éléments enfants de parent. Si row et column sont supérieurs ou égaux à zéro, cela signifie que le dépôt a eu lieu juste avant les éléments spécifiés row et column dans l’ spécifié.

La méthode mimeTypes() est appelée pour obtenir la liste des types MIME acceptés. Cette implémentation par défaut s'appuie sur l'implémentation par défaut de mimeTypes(), qui renvoie un seul type MIME par défaut. Si vous réimplémentez mimeTypes() dans votre modèle personnalisé pour renvoyer plusieurs types MIME, vous devez réimplémenter cette méthode pour pouvoir les utiliser.

Voir également supportedDropActions(), canDropMimeData() et Utilisation du glisser-déposer avec les vues d'éléments.

[protected] void QAbstractItemModel::endInsertColumns()

Mette fin à une opération d'insertion de colonne.

Lorsque vous réimplémentez la méthode insertColumns() dans une sous-classe, vous devez appeler cette fonction après avoir inséré les données dans le magasin de données sous-jacent du modèle.

Voir également beginInsertColumns().

[protected] void QAbstractItemModel::endInsertRows()

Mette fin à une opération d'insertion de ligne.

Lorsque vous réimplémentez la méthode insertRows() dans une sous-classe, vous devez appeler cette fonction après avoir inséré les données dans le magasin de données sous-jacent du modèle.

Voir également beginInsertRows().

[protected] void QAbstractItemModel::endMoveColumns()

Met fin à une opération de déplacement de colonne.

Lors de l'implémentation d'une sous-classe, vous devez appeler cette fonction après avoir déplacé les données au sein du magasin de données sous-jacent du modèle.

Voir également ` beginMoveColumns()`.

[protected] void QAbstractItemModel::endMoveRows()

Met fin à une opération de déplacement de ligne.

Lors de l'implémentation d'une sous-classe, vous devez appeler cette fonction après avoir déplacé des données au sein du magasin de données sous-jacent du modèle.

Voir également ` beginMoveRows()`.

[protected] void QAbstractItemModel::endRemoveColumns()

Met fin à une opération de suppression de colonne.

Lorsque vous réimplémentez la méthode removeColumns() dans une sous-classe, vous devez appeler cette fonction après avoir supprimé les données du magasin de données sous-jacent du modèle.

Voir également ` beginRemoveColumns()`.

[protected] void QAbstractItemModel::endRemoveRows()

Met fin à une opération de suppression de ligne.

Lorsque vous réimplémentez la méthode ` removeRows()` dans une sous-classe, vous devez appeler cette fonction après avoir supprimé les données du magasin de données sous-jacent du modèle.

Voir également beginRemoveRows().

[protected] void QAbstractItemModel::endResetModel()

Effectue une opération de réinitialisation du modèle.

Vous devez appeler cette fonction après avoir réinitialisé toute structure de données interne de votre modèle ou de votre modèle proxy.

Cette fonction émet le signal modelReset().

Voir également beginResetModel().

[virtual invokable] void QAbstractItemModel::fetchMore(const QModelIndex &parent)

Récupère toutes les données disponibles pour les éléments dont le parent est spécifié par l'index « parent ».

Réimplémentez cette méthode si vous remplissez votre modèle de manière incrémentielle.

L'implémentation par défaut ne fait rien.

Voir également canFetchMore().

[virtual invokable] Qt::ItemFlags QAbstractItemModel::flags(const QModelIndex &index) const

Renvoie les indicateurs de l'élément pour l'index donné.

L'implémentation de la classe de base renvoie une combinaison d'indicateurs qui active l'élément (ItemIsEnabled) et permet de le sélectionner (ItemIsSelectable).

Voir également Qt::ItemFlags.

[virtual invokable] bool QAbstractItemModel::hasChildren(const QModelIndex &parent = QModelIndex()) const

Renvoie ` true ` si ` parent ` possède des enfants ; sinon, renvoie ` false`.

Utilisez la méthode ` rowCount()` sur le parent pour connaître le nombre d'enfants.

Notez que le comportement est indéfini si cette méthode indique qu’un indice particulier possède des enfants alors que le drapeau Qt::ItemNeverHasChildren est activé pour cet indice.

Voir également parent() et index().

[invokable] bool QAbstractItemModel::hasIndex(int row, int column, const QModelIndex &parent = QModelIndex()) const

Renvoie « true » si le modèle renvoie une valeur valide de type « QModelIndex » pour « row » et « column » avec « parent » ; sinon, renvoie « false ».

[virtual invokable] QVariant QAbstractItemModel::headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const

Renvoie les données correspondant aux champs « role » et « section » de l'en-tête, avec la valeur spécifiée « orientation ».

Pour les en-têtes horizontaux, le numéro de section correspond au numéro de colonne. De même, pour les en-têtes verticaux, le numéro de section correspond au numéro de ligne.

Voir également Qt::ItemDataRole, setHeaderData() et QHeaderView.

[signal] void QAbstractItemModel::headerDataChanged(Qt::Orientation orientation, int first, int last)

Ce signal est émis chaque fois qu'un en-tête est modifié. L'orientation indique si c'est l'en-tête horizontal ou vertical qui a été modifié. Les sections de l'en-tête situées entre first et last doivent être mises à jour.

Lors de la réimplémentation de la fonction setHeaderData(), ce signal doit être émis explicitement.

Si vous modifiez le nombre de colonnes ou de lignes, vous n’avez pas besoin d’émettre ce signal, mais utilisez les fonctions begin/end (pour plus de détails, reportez-vous à la section sur la sous-classification dans la description de la classe QAbstractItemModel ).

Voir également headerData(), setHeaderData() et dataChanged().

[pure virtual invokable] QModelIndex QAbstractItemModel::index(int row, int column, const QModelIndex &parent = QModelIndex()) const

Renvoie l’index de l’élément du modèle spécifié par les index row, column et parent fournis.

Lorsque vous réimplémentez cette fonction dans une sous-classe, appelez ` createIndex()` pour générer des index de modèle que d’autres composants peuvent utiliser pour faire référence aux éléments de votre modèle.

Voir également ` createIndex()`.

[invokable] bool QAbstractItemModel::insertColumn(int column, const QModelIndex &parent = QModelIndex())

Insère une seule colonne avant la colonne « column » dans les éléments enfants de la table « parent » spécifiée.

Renvoie ` true ` si la colonne est insérée ; sinon, renvoie ` false`.

Voir également insertColumns(), insertRow() et removeColumn().

[virtual invokable] bool QAbstractItemModel::insertColumns(int column, int count, const QModelIndex &parent = QModelIndex())

Sur les modèles prenant en charge cette fonctionnalité, la commande ` count ` insère de nouvelles colonnes dans le modèle avant la colonne spécifiée ` column`. Les éléments de chaque nouvelle colonne seront des enfants de l'élément représenté par l'index du modèle ` parent `.

Si column vaut 0, les colonnes sont ajoutées au début de toutes les colonnes existantes.

Si column vaut columnCount(), les colonnes sont ajoutées à la fin de toutes les colonnes existantes.

Si parent n’a pas d’enfants, une seule ligne comportant count colonnes est insérée.

Renvoie ` true ` si les colonnes ont été insérées avec succès ; sinon, renvoie ` false`.

L'implémentation de la classe de base ne fait rien et renvoie ` false`.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge les insertions. Vous pouvez également fournir votre propre API pour modifier les données.

Voir également insertRows(), removeColumns(), beginInsertColumns() et endInsertColumns().

[invokable] bool QAbstractItemModel::insertRow(int row, const QModelIndex &parent = QModelIndex())

Insère une seule ligne avant l'row donné dans les éléments enfants de l'parent spécifié.

Renvoie ` true ` si la ligne est insérée ; sinon, renvoie ` false`.

Voir également insertRows(), insertColumn() et removeRow().

[virtual invokable] bool QAbstractItemModel::insertRows(int row, int count, const QModelIndex &parent = QModelIndex())

Sur les modèles qui prennent en charge cette fonctionnalité, cette fonction insère count lignes dans le modèle avant la ligne spécifiée row. Les éléments de la nouvelle ligne deviendront des enfants de l'élément représenté par l'index parent du modèle.

Si row vaut 0, les lignes sont ajoutées au début de toutes les lignes existantes dans le parent.

Si row vaut rowCount(), les lignes sont ajoutées à la fin des lignes existantes du parent.

Si parent n’a pas d’enfants, une seule colonne contenant count lignes est insérée.

Renvoie ` true ` si les lignes ont été insérées avec succès ; sinon, renvoie ` false`.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge les insertions. Vous pouvez également fournir votre propre API pour modifier les données. Dans les deux cas, vous devrez appeler ` beginInsertRows()` et ` endInsertRows()` pour signaler aux autres composants que le modèle a changé.

Voir également insertColumns(), removeRows(), beginInsertRows() et endInsertRows().

[virtual] QMap<int, QVariant> QAbstractItemModel::itemData(const QModelIndex &index) const

Renvoie une carte contenant les valeurs de tous les rôles prédéfinis dans le modèle pour l'élément situé à l'index e indiquée.

Réimplémentez cette fonction si vous souhaitez étendre son comportement par défaut afin d'inclure des rôles personnalisés dans la carte.

Voir également setItemData(), Qt::ItemDataRole et data().

[signal] void QAbstractItemModel::layoutAboutToBeChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)

Ce signal est émis juste avant la modification de la disposition d'un modèle. Les composants connectés à ce signal l'utilisent pour s'adapter aux changements de disposition du modèle.

Les sous-classes doivent mettre à jour tous les index de modèle persistants après avoir émis le signal `layoutAboutToBeChanged()`.

Le paramètre facultatif ` parents ` sert à fournir une notification plus précise concernant les parties de la disposition du modèle qui sont en train de changer. Une liste vide indique une modification de la disposition de l'ensemble du modèle. L'ordre des éléments dans la liste ` parents ` n'a pas d'importance. Le paramètre facultatif ` hint ` sert à donner une indication sur ce qui se passe pendant le réagencement du modèle.

Voir également layoutChanged() et changePersistentIndex().

[signal] void QAbstractItemModel::layoutChanged(const QList<QPersistentModelIndex> &parents = QList<QPersistentModelIndex>(), QAbstractItemModel::LayoutChangeHint hint = QAbstractItemModel::NoLayoutChangeHint)

Ce signal est émis chaque fois que la disposition des éléments exposés par le modèle a changé ; par exemple, lorsque le modèle a été trié. Lorsqu'une vue reçoit ce signal, elle doit mettre à jour la disposition des éléments afin de refléter ce changement.

Lorsque vous créez une sous-classe de ` QAbstractItemModel ` ou ` QAbstractProxyModel`, veillez à émettre ` layoutAboutToBeChanged()` avant de modifier l’ordre des éléments ou la structure des données que vous exposez aux vues, et à émettre `layoutChanged()` après avoir modifié la disposition.

Le paramètre facultatif ` parents ` sert à fournir une notification plus précise concernant les parties de la mise en page du modèle qui changent. Une liste vide indique une modification de la mise en page de l’ensemble du modèle. L’ordre des éléments dans la liste ` parents ` n’a pas d’importance. Le paramètre facultatif ` hint ` sert à donner une indication sur ce qui se passe pendant que le modèle est en cours de réorganisation.

Les sous-classes doivent mettre à jour tous les index persistants du modèle avant d’émettre `layoutChanged()`. En d’autres termes, lorsque la structure change :

• émettre layoutAboutToBeChanged
• N’oubliez pas l’ QModelIndex s qui va changer
• Mettez à jour vos données internes
• Appelez ` changePersistentIndex()`
• émettre layoutChanged

Voir également layoutAboutToBeChanged(), dataChanged(), headerDataChanged(), modelReset() et changePersistentIndex().

[virtual invokable] QModelIndexList QAbstractItemModel::match(const QModelIndex &start, int role, const QVariant &value, int hits = 1, Qt::MatchFlags flags = Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap)) const

Renvoie une liste d’index correspondant aux éléments de la colonne de l’index « start » pour lesquels les données stockées sous l’ role donné correspondent à la value spécifiée. La manière dont la recherche est effectuée est définie par l’ flags fourni. La liste renvoyée peut être vide. Notez également que l’ordre des résultats dans la liste peut ne pas correspondre à celui du modèle, si, par exemple, un modèle proxy est utilisé. L’ordre des résultats n’est pas fiable.

La recherche commence à partir de l’index start et se poursuit jusqu’à ce que le nombre d’éléments de données correspondants soit égal à hits, que la recherche atteigne la dernière ligne ou qu’elle revienne à start – selon que MatchWrap est spécifié ou non dans flags. Si vous souhaitez rechercher tous les éléments correspondants, utilisez hits = -1.

Par défaut, cette fonction effectue une comparaison par bouclage, basée sur les chaînes de caractères, sur tous les éléments, en recherchant ceux qui commencent par le terme de recherche spécifié par value.

[virtual] QMimeData *QAbstractItemModel::mimeData(const QModelIndexList &indexes) const

Renvoie un objet contenant des éléments de données sérialisés correspondant à la liste des éléments « indexes » spécifiée. Le format utilisé pour décrire les données encodées est obtenu à partir de la fonction ` mimeTypes()`. Cette implémentation par défaut utilise le type MIME par défaut renvoyé par l'implémentation par défaut de ` mimeTypes()`. Si vous réimplémentez ` mimeTypes()` dans votre modèle personnalisé afin de renvoyer davantage de types MIME, réimplémentez cette fonction pour les utiliser.

Si la liste de ` indexes ` est vide ou s’il n’existe aucun type MIME pris en charge, ` nullptr ` est renvoyé à la place d’une liste vide sérialisée.

Voir également mimeTypes() et dropMimeData().

[virtual] QStringList QAbstractItemModel::mimeTypes() const

Renvoie la liste des types MIME autorisés. Par défaut, les modèles et vues intégrés utilisent un type MIME interne : application/x-qabstractitemmodeldatalist.

Lorsque vous implémentez la prise en charge du glisser-déposer dans un modèle personnalisé, si vous comptez renvoyer des données dans des formats autres que le type MIME interne par défaut, réimplémentez cette fonction pour renvoyer votre liste de types MIME.

Si vous réimplémentez cette fonction dans votre modèle personnalisé, vous devez également réimplémenter les fonctions membres qui l'appellent : mimeData() et dropMimeData().

Voir également mimeData() et dropMimeData().

[private signal] void QAbstractItemModel::modelAboutToBeReset()

Ce signal est émis lorsque la méthode beginResetModel() est appelée, avant que l'état interne du modèle (par exemple, les index persistants du modèle) n'ait été invalidé.

Voir également ` beginResetModel()` et ` modelReset()`.

[private signal] void QAbstractItemModel::modelReset()

Ce signal est émis lorsque la méthode endResetModel() est appelée, après que l'état interne du modèle (par exemple, les index persistants du modèle) a été invalidé.

Notez que si un modèle est réinitialisé, toutes les informations précédemment récupérées à partir de celui-ci doivent être considérées comme invalides. Cela inclut, sans s’y limiter, les méthodes rowCount() et columnCount(), flags(), ainsi que les données récupérées via data() et roleNames().

Voir également endResetModel() et modelAboutToBeReset().

[invokable] bool QAbstractItemModel::moveColumn(const QModelIndex &sourceParent, int sourceColumn, const QModelIndex &destinationParent, int destinationChild)

Sur les modèles prenant en charge cette fonctionnalité, déplace le fichier « sourceColumn » de « sourceParent » vers « destinationChild » dans le répertoire « destinationParent ».

Renvoie true si le déplacement des colonnes a réussi ; sinon, renvoie false.

Voir également moveColumns() et moveRow().

[virtual invokable] bool QAbstractItemModel::moveColumns(const QModelIndex &sourceParent, int sourceColumn, int count, const QModelIndex &destinationParent, int destinationChild)

Sur les modèles prenant en charge cette fonctionnalité, déplace les colonnes count commençant par l'sourceColumn spécifiée, situées sous le parent sourceParent, vers la colonne destinationChild située sous le parent destinationParent.

Renvoie true si le déplacement des colonnes a réussi ; sinon, renvoie false.

L’implémentation de la classe de base ne fait rien et renvoie false.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge le déplacement. Vous pouvez également fournir votre propre API pour modifier les données.

Voir également beginMoveColumns() et endMoveColumns().

[invokable] bool QAbstractItemModel::moveRow(const QModelIndex &sourceParent, int sourceRow, const QModelIndex &destinationParent, int destinationChild)

Sur les modèles prenant en charge cette fonctionnalité, déplace le fichier « sourceRow » de « sourceParent » vers « destinationChild » dans le répertoire « destinationParent ».

Renvoie true si les lignes ont été déplacées avec succès ; sinon, renvoie false.

Voir également moveRows() et moveColumn().

[virtual invokable] bool QAbstractItemModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)

Sur les modèles prenant en charge cette fonctionnalité, déplace les lignes count commençant par l'sourceRow donné, situé sous le parent sourceParent, vers la ligne destinationChild située sous le parent destinationParent.

Renvoie true si le déplacement des lignes a réussi ; sinon, renvoie false.

L’implémentation de la classe de base ne fait rien et renvoie « false ».

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge le déplacement. Vous pouvez également fournir votre propre API pour modifier les données.

Voir également beginMoveRows() et endMoveRows().

[virtual, since 6.0] void QAbstractItemModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const

Remplit l'roleDataSpan avec les données demandées pour l'index donné.

L'implémentation par défaut se contentera d'appeler data() pour chaque rôle de la portée. Une sous-classe peut réimplémenter cette fonction afin de fournir des données aux vues de manière plus efficace :

void MyModel::multiData(const QModelIndex &index, QModelRoleDataSpan roleDataSpan) const
{
    for (QModelRoleData &roleData : roleDataSpan) {
        int role = roleData.role();

        // ... obtain the data for index and role ...

        roleData.setData(result);
    }
}

Dans l’extrait de code ci-dessus, ` index ` est identique pour l’ensemble de l’appel. Cela signifie que l’accès aux structures de données nécessaires pour récupérer les informations destinées à ` index ` ne peut être effectué qu’une seule fois (en extrayant le code pertinent hors de la boucle).

L’utilisation de ` QModelRoleData::setData()` ou, de manière similaire, de ` QVariant::setValue()` est privilégiée par rapport à la construction séparée d’un ` QVariant ` et à l’utilisation d’un simple opérateur d’affectation ; en effet, la première méthode permet de réutiliser la mémoire déjà allouée pour l’objet ` QVariant ` stocké dans un ` QModelRoleData`, tandis que la seconde alloue toujours une nouvelle instance puis détruit l’ancienne.

Notez que les vues peuvent appeler `multiData()` avec des `spans` qui ont été utilisés lors d’appels précédents et qui peuvent donc déjà contenir des données. Il est donc impératif que, si le modèle ne peut pas renvoyer les données pour un rôle donné, il efface les données contenues dans l’objet ` QModelRoleData ` correspondant. Cela peut se faire en appelant ` QModelRoleData::clearData()` ou, de manière similaire, en définissant un ` QVariant` construit par défaut, et ainsi de suite. Si les données ne sont pas effacées, la vue considérera que les « anciennes » données sont destinées à être utilisées pour le rôle correspondant.

Enfin, afin d’éviter la duplication de code, une sous-classe peut également décider de réimplémenter la méthode ` data()` en termes de `multiData()`, en fournissant une plage (span) ne contenant qu’un seul élément :

QVariant MyModel::data(const QModelIndex &index, int role) const
{
    QModelRoleData roleData(role);
    multiData(index, roleData);
    return roleData.data();
}

Cette fonction a été introduite dans Qt 6.0.

Voir également ` QModelRoleDataSpan ` et ` data()`.

[pure virtual invokable] QModelIndex QAbstractItemModel::parent(const QModelIndex &index) const

Renvoie le parent de l'élément du modèle dont l'index est spécifiée. Si l'élément n'a pas de parent, une QModelIndex non valide est renvoyée.

Une convention courante utilisée dans les modèles exposant des structures de données arborescentes est que seuls les éléments de la première colonne ont des enfants. Dans ce cas, lors de la réimplémentation de cette fonction dans une sous-classe, la colonne de l’ QModelIndex renvoyée serait 0.

Lors de la réimplémentation de cette fonction dans une sous-classe, veillez à ne pas appeler les fonctions membres d’ QModelIndex, telles que QModelIndex::parent(), car les index appartenant à votre modèle appelleront simplement votre implémentation, ce qui entraînera une récursion infinie.

Voir également createIndex().

[protected] QModelIndexList QAbstractItemModel::persistentIndexList() const

Renvoie la liste des index enregistrés en tant qu'index persistants dans le modèle.

[invokable] bool QAbstractItemModel::removeColumn(int column, const QModelIndex &parent = QModelIndex())

Supprime l'column on indiquée des éléments enfants de l'parent ion spécifiée.

Renvoie ` true ` si la colonne est supprimée ; sinon, renvoie ` false`.

Voir également removeColumns(), removeRow() et insertColumn().

[virtual invokable] bool QAbstractItemModel::removeColumns(int column, int count, const QModelIndex &parent = QModelIndex())

Sur les modèles prenant en charge cette fonctionnalité, supprime du modèle les colonnes de type « count » commençant par l’ column spécifiée, situées sous la parent.

Renvoie ` true ` si les colonnes ont été supprimées avec succès ; sinon, renvoie ` false`.

L'implémentation de la classe de base ne fait rien et renvoie false.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge la suppression. Vous pouvez également fournir votre propre API pour modifier les données.

Voir également removeColumn(), removeRows(), insertColumns(), beginRemoveColumns() et endRemoveColumns().

[invokable] bool QAbstractItemModel::removeRow(int row, const QModelIndex &parent = QModelIndex())

Supprime l'row donné des éléments enfants de l'parent spécifié.

Renvoie ` true ` si la ligne est supprimée ; sinon, renvoie ` false`.

Il s'agit d'une fonction de commodité qui appelle ` removeRows()`. L'implémentation ` QAbstractItemModel ` de ` removeRows()` ne fait rien.

Voir également removeRows(), removeColumn() et insertRow().

[virtual invokable] bool QAbstractItemModel::removeRows(int row, int count, const QModelIndex &parent = QModelIndex())

Sur les modèles prenant en charge cette fonctionnalité, supprime du modèle les lignes count commençant par l’ row donné, sous le parent parent.

Renvoie ` true ` si les lignes ont été supprimées avec succès ; sinon, renvoie ` false`.

L’implémentation de la classe de base ne fait rien et renvoie false.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez prendre en charge la suppression. Vous pouvez également fournir votre propre API pour modifier les données.

Voir également removeRow(), removeColumns(), insertColumns(), beginRemoveRows() et endRemoveRows().

[virtual protected slot] void QAbstractItemModel::resetInternalData()

Cet emplacement est appelé juste après l'effacement des données internes d'un modèle lors de sa réinitialisation.

Ce slot est fourni pour faciliter la tâche aux sous-classes de modèles proxy concrets, telles que les sous-classes de ` QSortFilterProxyModel ` qui gèrent des données supplémentaires.

class CustomDataProxy : public QSortFilterProxyModel
{
    Q_OBJECT
public:
    CustomDataProxy(QObject *parent)
      : QSortFilterProxyModel(parent)
    {
    }

    //...

    QVariant data(const QModelIndex &index, int role) const override
    {
        if (role != Qt::BackgroundRole)
            return QSortFilterProxyModel::data(index, role);

        if (m_customData.contains(index.row()))
            return m_customData.value(index.row());
        return QSortFilterProxyModel::data(index, role);
    }

private slots:
    void resetInternalData()
    {
        m_customData.clear();
    }

private:
  QHash<int, QVariant> m_customData;
};

Voir également modelAboutToBeReset() et modelReset().

[virtual slot] void QAbstractItemModel::revert()

Indique au modèle qu'il doit effacer les informations mises en cache. Cette fonction est généralement utilisée pour la modification de lignes.

Voir également submit().

[virtual] QHash<int, QByteArray> QAbstractItemModel::roleNames() const

Renvoie les noms des rôles du modèle.

Les noms de rôles par défaut définis par Qt sont les suivants :

[pure virtual invokable] int QAbstractItemModel::rowCount(const QModelIndex &parent = QModelIndex()) const

Renvoie le nombre de lignes associées à l'parent donné. Lorsque le parent est valide, cela signifie que la fonction rowCount renvoie le nombre d'enfants de ce parent.

Voir également columnCount().

[private signal] void QAbstractItemModel::rowsAboutToBeInserted(const QModelIndex &parent, int start, int end)

Ce signal est émis juste avant l'insertion de lignes dans le modèle. Les nouveaux éléments seront positionnés entre start et end inclus, sous l'élément parent donné.

Voir également insertRows() et beginInsertRows().

[private signal] void QAbstractItemModel::rowsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)

Ce signal est émis juste avant le déplacement de lignes au sein du modèle. Les éléments qui seront déplacés sont ceux situés entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné. Ils seront déplacés vers destinationParent à partir de la ligne destinationRow.

Remarque : les composants connectés à ce signal l’utilisent pour s’adapter aux changements de dimensions du modèle. Il ne peut être émis que par l’implémentation de QAbstractItemModel et ne peut pas être émis explicitement dans le code d’une sous-classe.

Voir également beginMoveRows().

[private signal] void QAbstractItemModel::rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)

Ce signal est émis juste avant que des lignes ne soient supprimées du modèle. Les éléments qui seront supprimés sont ceux situés entre first et last inclus, sous l'élément parent donné.

Voir également removeRows() et beginRemoveRows().

[private signal] void QAbstractItemModel::rowsInserted(const QModelIndex &parent, int first, int last)

Ce signal est émis après l’insertion de lignes dans le modèle. Les nouveaux éléments sont ceux situés entre ` first ` et ` last ` inclus, sous l’élément ` parent ` donné.

Voir également insertRows() et beginInsertRows().

[private signal] void QAbstractItemModel::rowsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destinationParent, int destinationRow)

Ce signal est émis après le déplacement de lignes au sein du modèle. Les éléments compris entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné, ont été déplacés vers destinationParent à partir de la ligne destinationRow.

Remarque : les composants connectés à ce signal l’utilisent pour s’adapter aux changements de dimensions du modèle. Il ne peut être émis que par l’implémentation de QAbstractItemModel et ne peut pas être émis explicitement dans le code d’une sous-classe.

Voir aussi beginMoveRows().

[private signal] void QAbstractItemModel::rowsRemoved(const QModelIndex &parent, int first, int last)

Ce signal est émis après la suppression de lignes du modèle. Les éléments supprimés sont ceux compris entre first et last inclus, sous l'élément parent donné.

Voir également removeRows() et beginRemoveRows().

[virtual invokable] bool QAbstractItemModel::setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole)

Définit la valeur de la clé « role » de l'élément situé à l'adresse index sur value.

Renvoie « true » en cas de réussite ; sinon, renvoie « false ».

Le signal dataChanged() doit être émis si les données ont été définies avec succès.

L'implémentation de la classe de base renvoie « false ». Cette fonction et « data() » doivent être réimplémentées pour les modèles modifiables.

Voir également Qt::ItemDataRole, data() et itemData().

[virtual] bool QAbstractItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role = Qt::EditRole)

Définit les données des champs « role » et « section » de l'en-tête, en utilisant l'adresse « orientation » spécifiée, sur l'adresse « value » fournie.

Renvoie true si les données de l'en-tête ont été mises à jour ; sinon, renvoie false.

Lors de la réimplémentation de cette fonction, le signal headerDataChanged() doit être émis explicitement.

Voir également Qt::ItemDataRole et headerData().

[virtual] bool QAbstractItemModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)

Définit les données de rôle de l'élément situé à l'adresse index sur la valeur associée dans roles, pour chaque Qt::ItemDataRole.

Renvoie true en cas de succès ; sinon, renvoie false.

Les rôles qui ne figurent pas dans roles ne seront pas modifiés.

Voir également setData(), data() et itemData().

[virtual invokable] QModelIndex QAbstractItemModel::sibling(int row, int column, const QModelIndex &index) const

Renvoie le frère situé à l'adresse row et column pour l'élément situé à l'adresse index, ou une valeur non valide de type QModelIndex s'il n'y a pas de frère à cet emplacement.

sibling() est simplement une fonction pratique qui trouve le parent de l’élément et l’utilise pour récupérer l’index de l’élément enfant aux emplacements spécifiés row et column.

Cette méthode peut éventuellement être redéfinie à des fins d’optimisation spécifiques à l’implémentation.

Voir également index(), QModelIndex::row() et QModelIndex::column().

[virtual invokable] void QAbstractItemModel::sort(int column, Qt::SortOrder order = Qt::AscendingOrder)

Trie le modèle selon l'column, dans l'order indiquée.

L'implémentation de la classe de base ne fait rien.

[virtual] QSize QAbstractItemModel::span(const QModelIndex &index) const

Renvoie la plage de lignes et de colonnes de l'élément représenté par index.

[virtual slot] bool QAbstractItemModel::submit()

Indique au modèle qu'il doit transférer les informations mises en cache vers un support de stockage permanent. Cette fonction est généralement utilisée pour la modification de lignes.

Renvoie ` true ` s'il n'y a pas d'erreur ; sinon, renvoie ` false`.

Voir également revert().

[virtual] Qt::DropActions QAbstractItemModel::supportedDragActions() const

Renvoie les actions prises en charge par les données de ce modèle.

L'implémentation par défaut renvoie ` supportedDropActions()`. Réimplémentez cette fonction si vous souhaitez prendre en charge des actions supplémentaires.

La fonction `supportedDragActions()` est utilisée par ` QAbstractItemView::startDrag()` comme valeurs par défaut lorsqu'un glisser-déposer se produit.

Voir également Qt::DropActions et Utilisation du glisser-déposer avec les vues d'éléments.

[virtual] Qt::DropActions QAbstractItemModel::supportedDropActions() const

Renvoie les actions de glisser-déposer prises en charge par ce modèle.

L'implémentation par défaut renvoie Qt::CopyAction. Réimplémentez cette fonction si vous souhaitez prendre en charge des actions supplémentaires. Vous devez également réimplémenter la fonction dropMimeData() pour gérer ces opérations supplémentaires.

Voir également dropMimeData(), Qt::DropActions et Utilisation du glisser-déposer avec les vues d'éléments.