QAbstractItemModel Class

Documentation des fonctions membres

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

Construit un modèle d'élément abstrait avec l'adresse parent.

[virtual noexcept] QAbstractItemModel::~QAbstractItemModel()

Détruit le modèle d'objet abstrait.

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

Commence une opération d'insertion de colonne.

Lorsque vous réimplémentez 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 de colonnes que les nouvelles colonnes auront après avoir été insérées.

Insertion de colonnes	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 diagramme, nous insérons trois colonnes avant la colonne 4, de sorte que first est 4 et last est 6 : beginInsertColumns(parent, 4, 6); Les trois nouvelles colonnes sont ainsi insérées en tant que colonnes 4, 5 et 6.
Ajout de colonnes	Pour ajouter des colonnes, insérez-les après la dernière colonne. Par exemple, comme le montre le diagramme, nous ajoutons trois colonnes à une collection de six colonnes existantes (se terminant par la colonne 5), de sorte que first est 6 et last est 8 : beginInsertColumns(parent, 6, 8); Les deux nouvelles colonnes sont donc ajoutées en tant que colonnes 6, 7 et 8.

Voir également endInsertColumns().

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

Commence une opération d'insertion de ligne.

Lorsque vous réimplémentez 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 auront après avoir été insérées.

Insertion de lignes	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 diagramme, nous insérons trois lignes avant la ligne 2, de sorte que first est 2 et last est 4 : beginInsertRows(parent, 2, 4); Les trois nouvelles lignes sont ainsi insérées en tant que lignes 2, 3 et 4.
Ajout de lignes	Pour ajouter des lignes, insérez-les après la dernière ligne. Par exemple, comme le montre le diagramme, nous ajoutons deux lignes à une collection de 4 lignes existantes (se terminant à la ligne 3), de sorte que first est 4 et last est 5 : beginInsertRows(parent, 4, 5); Les deux nouvelles lignes sont donc ajoutées 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)

Commence une opération de déplacement de colonne.

Lors de la réimplémentation d'une sous-classe, cette méthode simplifie le déplacement des entités dans votre modèle. Cette méthode est responsable du déplacement des index persistants dans le modèle, ce que vous devriez autrement faire vous-même. L'utilisation de beginMoveColumns et de endMoveColumns est une alternative à l'émission directe de layoutAboutToBeChanged et layoutChanged ainsi que de changePersistentIndex.

L'index sourceParent correspond au parent à partir duquel les colonnes sont déplacées ; sourceFirst et sourceLast sont les numéros de la première et de la dernière colonne des colonnes à déplacer. L'index destinationParent correspond au parent dans lequel ces colonnes sont déplacées. L'index destinationChild correspond à la colonne vers laquelle les colonnes seront déplacées. Ainsi, l'index de la colonne sourceFirst dans sourceParent deviendra la colonne destinationChild dans destinationParent, suivie de toutes les autres colonnes jusqu'à sourceLast.

Toutefois, lorsque vous déplacez des colonnes vers le bas dans le même parent (sourceParent et destinationParent sont égaux), les colonnes seront placées avant l'index destinationChild. En d'autres termes, si vous souhaitez déplacer les colonnes 0 et 1 pour qu'elles deviennent les colonnes 1 et 2, destinationChild doit être 3. Dans ce cas, le nouvel index de la colonne 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 destinationChild n'est pas compris entre sourceFirst et sourceLast + 1. Vous devez également vous assurer que vous n'essayez pas de déplacer une colonne vers l'un de ses propres enfants ou ancêtres. Cette méthode renvoie false si l'une des conditions est vraie, auquel cas vous devez abandonner 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)

Commence une opération de déplacement de ligne.

Lors de la réimplémentation d'une sous-classe, cette méthode simplifie le déplacement d'entités dans votre modèle. Cette méthode est responsable du déplacement des index persistants dans le modèle, ce que vous devriez autrement faire vous-même. L'utilisation de beginMoveRows et de endMoveRows est 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 les numéros de la première et de la dernière ligne des lignes à déplacer. L'index destinationParent correspond au parent dans lequel ces lignes sont déplacées. L'index destinationChild correspond à la ligne vers laquelle les lignes seront déplacées. Ainsi, l'index de la ligne sourceFirst dans sourceParent deviendra la ligne destinationChild dans destinationParent, suivie de toutes les autres lignes jusqu'à sourceLast.

Toutefois, lorsque vous déplacez des lignes vers le bas dans le même parent (sourceParent et destinationParent sont égaux), les lignes seront placées avant l'index destinationChild. En d'autres termes, si vous souhaitez déplacer les lignes 0 et 1 pour qu'elles deviennent les lignes 1 et 2, destinationChild doit être 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 destinationChild n'est pas compris entre sourceFirst et sourceLast + 1. Vous devez également vous assurer que vous n'essayez pas de déplacer une ligne vers l'un de ses propres enfants ou ancêtres. Cette méthode renvoie false si l'une de ces conditions est remplie, auquel cas vous devez interrompre votre opération de déplacement.

Déplacement de lignes vers un autre parent	Indiquez les numéros de la première et de la dernière ligne de l'étendue des lignes du parent source que vous souhaitez déplacer dans le modèle. Indiquez également la ligne du parent de destination vers laquelle déplacer l'étendue. Par exemple, comme le montre le diagramme, nous déplaçons trois rangées de la rangée 2 à la rangée 4 dans la source, de sorte que sourceFirst est 2 et sourceLast est 4. Nous déplaçons ces éléments au-dessus de la rangée 2 dans la destination, de sorte que destinationChild est 2. beginMoveRows(sourceParent, 2, 4, destinationParent, 2); Les trois lignes 2, 3 et 4 de la source deviennent ainsi 2, 3 et 4 dans la destination. Les autres frères et sœurs concernés sont déplacés en conséquence.
Déplacement de lignes pour les ajouter à un autre parent	Pour ajouter des lignes à un autre parent, déplacez-les après la dernière ligne. Par exemple, comme le montre le diagramme, nous déplaçons trois rangées vers une collection de 6 rangées existantes (se terminant par la rangée 5), de sorte que destinationChild est 6 : beginMoveRows(sourceParent, 2, 4, destinationParent, 6); Cela déplace les lignes cibles à la fin du parent cible en tant que 6, 7 et 8.
Déplacement de lignes dans le même parent vers le haut	Pour déplacer des lignes à l'intérieur du même parent, indiquez la ligne vers laquelle elles doivent être déplacées. Par exemple, comme le montre le diagramme, nous déplaçons un élément de la rangée 2 à la rangée 0, de sorte que sourceFirst et sourceLast sont 2 et destinationChild est 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 à l'intérieur d'un même parent, vous ne devez pas tenter des déplacements non valides ou sans option. 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é à la ligne 2 (où il se trouve déjà) ou à la ligne 3 (sans objet car la ligne 3 signifie au-dessus de la ligne 3, où il se trouve déjà).
Déplacement de lignes dans le même parent vers le bas	Pour déplacer des lignes à l'intérieur d'un même parent, indiquez la ligne vers laquelle les déplacer. Par exemple, comme le montre le diagramme, nous déplaçons un élément de la ligne 2 à la ligne 4, de sorte que 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 aussi endMoveRows().

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

Commence une opération de suppression de colonne.

Lorsque vous réimplémentez removeColumns() dans une sous-classe, vous devez appeler cette fonction avant de supprimer les 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 colonne de la première et de la dernière colonne à supprimer.

Suppression de colonnes

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 diagramme, nous supprimons les trois colonnes de la colonne 4 à la colonne 6, de sorte que first est 4 et last est 6 : beginRemoveColumns(parent, 4, 6);

Voir aussi endRemoveColumns().

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

Commence une opération de suppression de ligne.

Lorsque vous réimplémentez removeRows() dans une sous-classe, vous devez appeler cette fonction avant de supprimer les 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.

Suppression de lignes

Spécifiez les numéros de la première et de la dernière ligne de l'étendue des lignes que vous souhaitez supprimer d'un élément d'un modèle. Par exemple, comme le montre le diagramme, nous supprimons les deux rangées allant de la rangée 2 à la rangée 3, de sorte que first est 2 et last est 3 : beginRemoveRows(parent, 2, 3);

Voir aussi endRemoveRows().

[protected] void QAbstractItemModel::beginResetModel()

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

Une opération de réinitialisation remet le modèle dans son état actuel dans toutes les vues attachées.

Lorsqu'un modèle est réinitialisé, cela signifie que toutes les données précédentes rapportées par le modèle sont désormais invalides et doivent être redemandées. Cela signifie également que l'élément actuel et tous les éléments sélectionnés deviennent invalides.

Lorsqu'un modèle modifie radicalement ses données, il est parfois plus facile d'appeler cette fonction plutôt que d'émettre 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 les structures de données internes de votre modèle ou de votre modèle mandataire.

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 pour le copain 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 un autre élément du modèle doit être modifié à la place. Ensuite, la vue construira un délégué en utilisant l'index de modèle renvoyé par l'élément "buddy".

Dans l'implémentation par défaut de cette fonction, chaque élément est son propre compagnon.

[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 un dépôt de data. Cette implémentation par défaut ne vérifie que si data a au moins un format dans la liste de mimeTypes() et si action fait partie des supportedDropActions() du modèle.

Réimplémentez cette fonction dans votre modèle personnalisé si vous voulez tester si le data peut être déposé à 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 plus 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 le comportement de QAbstractItemView, par exemple.

Voir également fetchMore().

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

Remplace le QPersistentModelIndex correspondant à l'indice de modèle from par l'indice de modèle to.

Si aucun index de modèle persistant correspondant à l'index de modèle from n'a été trouvé, rien n'est modifié.

Voir aussi persistentIndexList() et changePersistentIndexList().

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

Change les {QPersistentModelIndex}es qui sont égaux aux index de la liste d'index du modèle from donnée en liste d'index du modèle to donnée.

Si aucun index de modèle persistant égal aux index de la liste d'index de modèle from n'est trouvé, rien n'est modifié.

Voir aussi 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 légal pour ce modèle. Un index de modèle légal est soit un index de modèle invalide, 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 du parent de l'index ;
• la colonne "index" est supérieure ou égale à zéro ;
• la colonne de l'index est inférieure au nombre de colonnes du parent de l'index.

L'argument options peut modifier certaines de ces vérifications. Si options contient IndexIsValid, alors index doit être un index valide ; ceci 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 à partir d'une réimplémentation de parent() (sinon, cela entraînerait une récursion sans fin et un plantage).

Si options ne contient pas DoNotUseParent et qu'il contient ParentIsInvalid, une vérification supplémentaire est effectuée : l'index parent est vérifié pour s'assurer qu'il n'est pas valide. Cette vérification est utile lors de la mise en œuvre de modèles plats tels que des listes ou des tableaux, où aucun index de modèle ne doit avoir d'index parent valide.

Cette fonction renvoie true si toutes les vérifications ont réussi, 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 a échoué, un message d'avertissement sera imprimé dans la catégorie de journalisation qt.core.qabstractitemmodel.checkindex, contenant des informations qui peuvent être utiles pour le débogage de l'échec.

Voir aussi QModelIndex.

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

Supprime les données stockées dans tous les rôles pour l'adresse index. Retourne true en cas de succès ; sinon, retourne 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 aussi data(), itemData(), setData() et setItemData().

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

Renvoie le nombre de colonnes pour les enfants de la classe donnée parent.

Dans la plupart des sous-classes, le nombre de colonnes est indépendant de 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 donné.

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 que les colonnes ne soient déplacées dans le modèle. Les éléments qui seront déplacés sont ceux qui se trouvent entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné. Ils seront déplacés vers destinationParent à partir de la colonne destinationColumn.

Note : 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 explicitement émis 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 qui se trouvent 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 après l'insertion de colonnes 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 que des colonnes ont été déplacées dans le 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 colonne destinationColumn.

Note : 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 explicitement émis 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 lorsque 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().

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

Crée un index de modèle pour les données row et column avec le pointeur interne ptr.

Lors de l'utilisation d'un QSortFilterProxyModel, ses index ont leur propre pointeur interne. Il n'est pas conseillé 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 de 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 données row et column avec l'identifiant interne id.

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

Voir aussi QModelIndex::internalId().

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

Renvoie les données stockées sous l'adresse role donnée pour l'élément auquel renvoie l'adresse 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 lorsque les données d'un élément existant changent.

Si les éléments appartiennent au même parent, les éléments concernés sont ceux situés 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 spécifier quels rôles de données ont été effectivement 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 pas d'importance.

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

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

Traite les data fournis par une opération de glisser-déposer qui s'est terminée par le action donné.

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

Les valeurs spécifiées row, column et parent indiquent l'emplacement d'un élément du modèle où l'opération s'est terminée. Il incombe au modèle de terminer l'action au bon endroit.

Par exemple, une action de dépôt sur un élément du modèle QTreeView peut entraîner l'insertion de nouveaux éléments en tant qu'enfants de l'élément spécifié par row, column et parent, ou en tant que frères et sœurs de l'élément.

Lorsque row et column sont -1, cela signifie que les données déposées doivent être considérées comme déposées directement sur parent. En général, cela signifie que les données sont ajoutées en tant qu'éléments enfants de parent. Si row et column sont supérieurs ou égaux à zéro, cela signifie que l'abandon s'est produit juste avant les éléments spécifiés row et column dans l'élément spécifié parent.

Le membre mimeTypes() est appelé pour obtenir la liste des types MIME acceptables. Cette implémentation par défaut suppose 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 fonction pour les utiliser.

Voir aussi supportedDropActions(), canDropMimeData(), et Utiliser le glisser-déposer avec les vues d'éléments.

[protected] void QAbstractItemModel::endInsertColumns()

Termine une opération d'insertion de colonne.

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

Voir aussi beginInsertColumns().

[protected] void QAbstractItemModel::endInsertRows()

Termine une opération d'insertion de ligne.

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

Voir aussi beginInsertRows().

[protected] void QAbstractItemModel::endMoveColumns()

Termine 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é des données dans le magasin de données sous-jacent du modèle.

Voir également beginMoveColumns().

[protected] void QAbstractItemModel::endMoveRows()

Termine 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 dans le magasin de données sous-jacent du modèle.

Voir également beginMoveRows().

[protected] void QAbstractItemModel::endRemoveColumns()

Termine une opération de suppression de colonne.

Lorsque vous réimplémentez 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 aussi beginRemoveColumns().

[protected] void QAbstractItemModel::endRemoveRows()

Termine une opération de suppression de ligne.

Lorsque vous réimplémentez 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 aussi beginRemoveRows().

[protected] void QAbstractItemModel::endResetModel()

Termine 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 dans votre modèle ou modèle mandataire.

Cette fonction émet le signal modelReset().

Voir aussi 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 ceci si vous remplissez votre modèle de manière incrémentale.

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

Voir également canFetchMore().

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

Renvoie les drapeaux de l'élément pour le site index donné.

L'implémentation de la classe de base renvoie une combinaison de drapeaux 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 a des enfants ; sinon, renvoie false.

Utilisez rowCount() sur le parent pour connaître le nombre d'enfants.

Notez qu'il n'est pas défini de signaler qu'un index particulier a des enfants avec cette méthode si le même index a l'indicateur Qt::ItemNeverHasChildren activé.

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 un QModelIndex valide 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 pour les adresses role et section dans l'en-tête avec l'adresse 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é. Le orientation indique si l'en-tête horizontal ou vertical a été modifié. Les sections de l'en-tête 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, il n'est pas nécessaire d'émettre ce signal, mais d'utiliser les fonctions begin/end (pour plus de détails, reportez-vous à la section sur la sous-classe 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 l'index row, column et parent donné.

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 à des éléments de votre modèle.

Voir également createIndex().

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

Insère une colonne unique avant l'élément column dans les éléments enfants de l'élément parent spécifié.

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 qui le supportent, insère count de nouvelles colonnes dans le modèle avant la colonne donné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 à toutes les colonnes existantes.

Si column est columnCount(), les colonnes sont ajoutées à toutes les colonnes existantes.

Si parent n'a pas d'enfant, une seule ligne contenant les colonnes de count 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 le site row dans les éléments enfants du site parent spécifié.

Elle renvoie true si la ligne est insérée, sinon elle 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 fonction, elle insère les lignes count dans le modèle avant la ligne row donnée. Les éléments de la nouvelle ligne seront des enfants de l'élément représenté par l'index du modèle parent.

Si row vaut 0, les lignes sont ajoutées à toutes les lignes existantes dans le modèle parent.

Si row est rowCount(), les lignes sont ajoutées à toutes les lignes existantes du parent.

Si parent n'a pas d'enfant, une seule colonne contenant les lignes de count 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 informer les 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 à l'adresse index.

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

Voir aussi 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 que la disposition d'un modèle ne soit modifiée. Les composants connectés à ce signal l'utilisent pour s'adapter aux modifications de la présentation du modèle.

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

Le paramètre optionnel parents est utilisé pour donner une notification plus spécifique sur les parties de la disposition du modèle qui sont en train de changer. Une liste vide indique une modification de la présentation de l'ensemble du modèle. L'ordre des éléments dans la liste parents n'est pas significatif. Le paramètre facultatif hint est utilisé pour donner un indice sur ce qui se passe pendant que le modèle est relayé.

Voir également layoutChanged() et changePersistentIndex().

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

Ce signal est émis lorsque la disposition des éléments exposés par le modèle a changé, par exemple lorsque le modèle a été trié. Lorsque ce signal est reçu par une vue, celle-ci doit mettre à jour la disposition des éléments pour refléter ce changement.

Lorsque vous sous-classez 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 est utilisé pour donner une notification plus spécifique sur les parties de la présentation du modèle qui sont modifiées. Une liste vide indique une modification de la présentation de l'ensemble du modèle. L'ordre des éléments dans la liste parents n'est pas significatif. Le paramètre optionnel hint est utilisé pour donner un indice sur ce qui se passe pendant que le modèle est relayé.

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

• emit layoutAboutToBeChanged
• Se souvenir de l'adresse QModelIndex qui va changer
• Mettez à jour vos données internes
• Appeler changePersistentIndex()
• emit layoutChanged

Voir aussi 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 pour les éléments de la colonne de l'index start où les données stockées sous l'adresse role correspondent à l'adresse value. La manière dont la recherche est effectuée est définie par l'adresse flags. La liste renvoyée peut être vide. Notez également que l'ordre des résultats dans la liste peut ne pas correspondre à l'ordre dans le 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 atteigne à nouveau 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 enveloppante, basée sur une chaîne de caractères, sur tous les éléments, en recherchant les éléments qui commencent par le terme de recherche spécifié par value.

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

Renvoie un objet contenant des données sérialisées correspondant à la liste de 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é pour renvoyer d'autres types MIME, réimplémentez cette fonction pour les utiliser.

Si la liste de indexes est vide, ou s'il n'y a pas de types MIME pris en charge, nullptr est renvoyé au lieu d'une liste vide sérialisée.

Voir aussi mimeTypes() et dropMimeData().

[virtual] QStringList QAbstractItemModel::mimeTypes() const

Renvoie la liste des types MIME autorisés. Par défaut, les modèles et les 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 renvoyez 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 beginResetModel() est appelé, avant que l'état interne du modèle (par exemple les index persistants du modèle) n'ait été invalidé.

Voir aussi beginResetModel() et modelReset().

[private signal] void QAbstractItemModel::modelReset()

Ce signal est émis lorsque endResetModel() est appelé, 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é, il faut considérer que toutes les informations précédemment extraites sont invalides. Ceci inclut, mais n'est pas limité à rowCount() et columnCount(), flags(), les données récupérées par 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 qui le permettent, déplace sourceColumn de sourceParent à destinationChild sous destinationParent.

Renvoie true si les colonnes ont été déplacées avec succès ; 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 qui le permettent, déplace les colonnes count commençant par sourceColumn sous le parent sourceParent vers la colonne destinationChild sous le parent destinationParent.

Renvoie true si les colonnes ont été déplacé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 déplacements. 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 qui le permettent, déplace sourceRow de sourceParent à destinationChild sous 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 qui le permettent, déplace les lignes count commençant par sourceRow sous le parent sourceParent vers la ligne destinationChild sous le parent destinationParent.

Renvoie true si les lignes ont été déplacé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 déplacements. 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 le site roleDataSpan avec les données demandées pour le site index.

L'implémentation par défaut appelle simplement data() pour chaque rôle dans l'étendue. Une sous-classe peut réimplémenter cette fonction pour 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 ci-dessus, index est le même pour tout l'appel. Cela signifie que l'accès aux structures de données nécessaires pour récupérer les informations pour index ne peut être effectué qu'une seule fois (en sortant le code concerné de la boucle).

L'utilisation de QModelRoleData::setData(), ou de manière similaire de QVariant::setValue(), est encouragée plutôt que la construction d'un QVariant séparément et l'utilisation d'un simple opérateur d'affectation ; en effet, le premier permet de réutiliser la mémoire déjà allouée pour l'objet QVariant stocké à l'intérieur d'un QModelRoleData, tandis que le second alloue toujours la nouvelle variante et détruit ensuite l'ancienne.

Il convient de noter que les vues peuvent appeler multiData() avec des portées qui ont été utilisées lors d'appels précédents et qui peuvent donc déjà contenir des données. Par conséquent, il est impératif que si le modèle ne peut pas renvoyer les données pour un rôle donné, il doit effacer les données dans l'objet QModelRoleData correspondant. Cela peut être fait en appelant QModelRoleData::clearData(), ou de la même manière en définissant un défaut construit QVariant, et ainsi de suite. Si les données ne sont pas effacées, la vue croira que les "anciennes" données sont destinées à être utilisées pour le rôle correspondant.

Enfin, afin d'éviter la duplication du code, une sous-classe peut également décider de réimplémenter data() en termes de multiData(), en fournissant une portée d'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 aussi QModelRoleDataSpan et data().

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

Renvoie le parent de l'élément de modèle avec l'adresse index. Si l'élément n'a pas de parent, une adresse QModelIndex invalide est renvoyée.

Une convention courante utilisée dans les modèles qui exposent 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'adresse QModelIndex renvoyée sera 0.

Lorsque vous réimplémentez cette fonction dans une sous-classe, veillez à éviter d'appeler les fonctions membres de QModelIndex, telles que QModelIndex::parent(), car les index appartenant à votre modèle appelleront simplement votre implémentation, ce qui entraînera une récursivité infinie.

Voir également createIndex().

[protected] QModelIndexList QAbstractItemModel::persistentIndexList() const

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

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

Supprime la colonne column des éléments enfants de la colonne parent 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 qui le supportent, supprime du modèle les colonnes count commençant par la valeur donnée column sous le parent 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'élément row donné des éléments enfants de l'élément parent spécifié.

Retourne true si la ligne est supprimée ; sinon, retourne 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 qui le supportent, supprime du modèle les lignes count commençant par l'adresse row donnée 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()

Ce slot 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 la commodité des sous-classes de modèles proxy concrets, tels que les sous-classes de QSortFilterProxyModel qui maintiennent 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 aussi modelAboutToBeReset() et modelReset().

[virtual slot] void QAbstractItemModel::revert()

Indique au modèle qu'il doit supprimer les informations mises en cache. Cette fonction est généralement utilisée pour l'édition des lignes.

Voir aussi submit().

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

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

Les noms de rôle 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 sous l'adresse parent. Lorsque le parent est valide, cela signifie que rowCount renvoie le nombre d'enfants du 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 que les lignes ne soient déplacées dans le modèle. Les éléments qui seront déplacés sont ceux qui se trouvent entre sourceStart et sourceEnd inclus, sous l'élément sourceParent donné. Ils seront déplacés vers destinationParent à partir de la ligne destinationRow.

Note : 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 explicitement émis 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 les lignes ne soient supprimées du modèle. Les éléments qui seront supprimés sont ceux qui se trouvent 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 que des lignes ont été déplacées dans le 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.

Note : 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 explicitement émis dans le code d'une sous-classe.

Voir également beginMoveRows().

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

Ce signal est émis après que des lignes ont été supprimées du modèle. Les éléments supprimés sont ceux qui se trouvent 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 les données de role pour l'élément à index à value.

Retourne true en cas de succès ; sinon, retourne 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 pour les role et section donnés dans l'en-tête avec le orientation spécifié à value fourni.

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

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

Voir aussi Qt::ItemDataRole et headerData().

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

Définit les données de rôle pour l'élément à l'adresse index à 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 aussi setData(), data() et itemData().

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

Renvoie le frère à row et column pour l'élément à index, ou un QModelIndex invalide s'il n'y a pas de frère à cet endroit.

sibling() est juste une fonction de commodité qui trouve le parent de l'élément et l'utilise pour récupérer l'index de l'élément enfant dans les emplacements spécifiés row et column.

Cette méthode peut être optionnellement surchargée pour une optimisation spécifique à 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 par column dans le répertoire order.

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

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

Renvoie l'étendue de la ligne et de la colonne de l'élément représenté par index.

[virtual slot] bool QAbstractItemModel::submit()

Indique au modèle qu'il doit soumettre les informations mises en cache au stockage permanent. Cette fonction est généralement utilisée pour l'édition de lignes.

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

Voir aussi 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.

supportedDragActions() est utilisé par QAbstractItemView::startDrag() comme valeurs par défaut lorsqu'un glissement 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 dépôt 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 les opérations supplémentaires.

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