QAbstractItemModel

La classe QAbstractItemModel fournit une interface abstraite pour les classes modèle d'élément. Plus d'informations...

 #include <QAbstractItemModel>

Héritage

Hérite de QObject.

Héritage

Hérité par QAbstractListModel, QAbstractProxyModel, QAbstractTableModel, QDirModel, QFileSystemModel, QHelpContentModel, QProxyModel et QStandardItemModel.

Description détaillée

La classe QAbstractItemModel fournit une interface abstraite pour les classes modèles d'élément.

La classe QAbstractItemModel définit une interface standard que les modèles d'élément doivent utiliser pour interopérer avec les autres composants de l'architecture modèle/vue. La classe n'est pas directement instanciable. Par contre, vous pouvez en hériter pour créer de nouveaux modèles.

La classe QAbstractItemModel est l'une des classes modèle/vue et fait partie du framework modèle/vue de Qt.

Si vous avez besoin d'un modèle pour l'utiliser avec une QListView ou une QTableView, vous devriez plutôt envisager de dériver la classe QAbstractListModel ou QAbstractTableModel plutôt que cette classe.

Le modèle de données sous-jacent est exposé aux vues et délégués sous forme d'une hiérarchie de tableaux. Si vous n'utilisez pas cette hiérarchie, alors le modèle est une simple table de lignes et colonnes. Chaque élément possède un index unique spécifié par un QModelIndex.

Chaque élément de donnée auquel on peut accéder via un modèle possède un index de modèle associé. Vous pouvez obtenir cet index de modèle en utilisant la fonction index(). Chaque index peut avoir un index frère ; les éléments enfants possèdent un index parent.

Chaque élément est associé à des éléments de données associés et ceux-ci peuvent être récupérés en spécifiant un rôle (voir Qt::ItemDataRole) à la fonction data() du modèle. Les données de tous les rôles disponibles peuvent être récupérées en même temps avec la fonction itemData().

Les données pour chaque rôle sont définies en utilisant un Qt::ItemDataRole particulier. Les données pour les rôles individuels sont définies individuellement avec la fonction setData() ou elles peuvent être définies pour tous les rôles avec la fonction setItemData().

Les éléments peuvent être testés avec la fonction flags() (voir Qt::ItemFlag) pour savoir s'ils peuvent être sélectionnés, déplacés ou manipulés de différentes façons.

Si un élément possède des objets enfants, la fonction hasChildren() retourne true pour l'index correspondant.

Le modèle possède une fonction rowCount() et une fonction columnCount() pour chaque niveau de la hiérarchie. Les lignes et colonnes peuvent être insérées et retirées avec les fonctions insertRows(), insertColumns(), removeRows() et removeColumns().

Le modèle envoie des signaux pour informer des changements. Par exemple, le signal dataChanged() est envoyé à chaque fois que des éléments de données du modèle sont modifiés. Les changements des entêtes fournis par le modèle provoquent l'émission du signal headerDataChanged(). Si la structure des données sous-jacentes change, le modèle peut envoyer le signal layoutChanged() pour informer les vues qu'elles doivent réafficher les éléments présentés, en prenant la nouvelle structure en compte.

On peut effectuer une recherche de données particulières dans les éléments accessibles par le modèle en utilisant la fonction match().

Pour trier le modèle, vous pouvez utiliser la fonction sort().

Dérivation

Note : des guides génériques pour la dérivation de modèles sont disponibles dans la documentation de la dérivation de modèle.

Lors de la dérivation de QAbstractItemModel, vous devez au moins implémenter les fonctions index(), parent(), rowCount(), columnCount() et data(). Ces fonctions sont utilisées dans tous les modèles en lecture seule et forment les bases des modèles éditables.

Vous pouvez aussi réimplémenter la fonction hasChildren() pour fournir un comportement spécial aux modèles dans lesquels l'implémentation de la fonction rowCount() est coûteuse. Cela permet aux modèles de limiter le nombre de données requises par les vues et peut être utilisé pour implémenter un remplissage retardé des données du modèle.

Afin de permettre l'édition du modèle, vous devez aussi implémenter les fonctions setData() et flags() afin que ItemIsEditable soit renvoyé. Vous pouvez aussi redéfinir les fonctions headerData() et setHeaderData() pour contrôler la façon dont les entêtes de votre modèle sont affichés.

Les signaux dataChanged() et headerDataChanged() doivent être émis explicitement lors de la réimplémentation respectivement des fonctions setData() et setHeaderData().

Les modèles personnalisés doivent créer des index de modèle à l'usage des autres composants. Pour ce faire, appelez la fonction createIndex() avec les numéros de ligne et de colonne appropriés pour l'élément, ainsi qu'un identificateur pointeur ou entier pour cet élément. La combinaison de ces valeurs doit être unique pour chaque élément. Les modèles personnalisés utilisent typiquement ces identificateurs uniques dans les autres fonctions réimplémentées pour retrouver les données des éléments et accéder aux informations des parents et enfants de l'élément. Voir l'exemple de modèle arbre simple pour plus d'informations à propos des identificateurs uniques.

Il n'est pas nécessaire de gérer chaque rôle défini dans Qt::ItemDataRole. Selon le type de données contenu dans le modèle, il peut être suffisant d'implémenter la fonction data() pour renvoyer les informations valides pour les rôles les plus communs. La plupart des modèles fournissent au moins la représentation textuelle des données de l'élément pour le rôle Qt::DisplayRole et les modèles devraient de préférence aussi fournir des informations valides pour les rôles Qt::ToolTipRole et Qt::WhatsThisRole, ces rôles permettant aux modèles d'être utilisés par les vues standard de Qt. Toutefois, pour certains modèles gérant des données très spécialisées, il peut être approprié de ne fournir des données que pour des rôles définis par l'utilisateur.

Les modèles qui fournissent des interfaces pour les structures de données redimensionnables peuvent fournir les implémentations des fonctions insertRows(), removeRows(), insertColumns(), et removeColumns(). Lors de l'implémentation de ces fonctions, il est important d'informer les vues connectées de tout changement des dimensions du modèle avant et après qu'ils aient lieu :

• Une implémentation de la fonction insertRows() doit appeler beginInsertRows() avant l'insertion des nouvelles lignes dans la structure de données et endInsertRows() immédiatement après.
• Une implémentation de la fonction insertColumns() doit appeler beginInsertColumns() avant l'insertion des nouvelles colonnes dans la structure de données et endInsertColumns() immédiatement après.
• Une implémentation de la fonction removeRows() doit appeler beginRemoveRows() avant la suppression des lignes de la structure de données et endRemoveRows() immédiatement après.
• Une implémentation de la fonction removeColumns() doit appeler beginRemoveColumns() avant la suppression des colonnes de la structure de données et endRemoveColumns() immédiatement après.

Les signaux privés que ces fonctions émettent donnent aux composants attachés la possibilité d'effectuer des actions avant que des données deviennent indisponibles. L'encapsulation des opérations d'insertion et de suppression avec ces fonctions de début et de fin permet aussi au modèle de gérer la persistance des index de modèles correctement. Pour que les sélections soient correctement gérées, vous devez vous assurer que vous appelez ces fonctions. Si vous insérez ou supprimez un élément ayant des enfants, vous n'avez pas besoin d'appeler ces fonctions sur les éléments enfants. Autrement dit, l'élément parent va s'occuper de ses éléments enfants.

Pour créer des modèles se peuplant incrémentalement, vous pouvez réimplementer les fonctions fetchMore() et canFetchMore(). Si la réimplementation de la fonction fetchMore() ajoute des lignes dans le modèle, les fonctions beginInsertRows() et endInsertRows() doivent être appelées.

Voir aussi Classes modèles, Référence pour la dérivation de modèle, QModelIndex, QAbstractItemView, Utilisation du glisser/déposer avec les vues d'éléments, Exemple de modèle DOM simple, Exemple de modèle en arbre simple, Exemple de modèle en arbre éditable et Exemple "Plus d'éléments".

Fonctions membres

QAbstractItemModel::QAbstractItemModel ( QObject * parent = 0 )

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

QAbstractItemModel::~QAbstractItemModel () [virtual]

Détruit le modèle d'élément abstrait.

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

Commence une opération d'insertion de colonnes.

Lors de la réimplémentation de la fonction insertColumns() dans une sous-classe, vous devez appeler cette fonction avant l'insertion des données dans le modèle stockant les données.

L'index parent correspond au parent dans lequel les nouvelles colonnes sont insérées ; first et last sont les numéros de colonne des nouvelles colonnes après leur insertion (premier et dernier numéro).

	Spécifie le premier et dernier numéro de colonne pour la liste de colonnes que vous voulez insérer dans un élément du modèle. Comme présenté dans le diagramme, nous insérons trois colonnes avant la colonne 4, donc first vaut 4 et last vaut 6 : beginInsertColumns(parent, 4, 6); Cela insère les trois nouvelles colonnes aux positions 4, 5 et 6.
	Pour ajouter des colonnes à la fin, insérez-les après la dernière colonne. Comme présenté dans le diagramme, nous rajoutons trois colonnes à un ensemble de six colonnes existantes (finissant à la colonne 5), donc first vaut 6 et last vaut 8 : beginInsertColumns(parent, 6, 8); Cela ajoute les trois nouvelles colonnes aux positions 6, 7 et 8.

Note : cette fonction émet le signal columnsAboutToBeInserted() que les vues ou les proxy connectés doivent traiter avant l'insertion des données. Sinon, les vues pourront se trouver dans un état invalide.

Voir aussi endInsertColumns().

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

Commence une opération d'insertion de lignes.

Lors de la réimplémentation de la fonction insertRows() dans une sous-classe, vous devez appeler cette fonction avant l'insertion des données dans le modèle stockant les données.

L'index parent correspond au parent dans lequel les nouvelles lignes seront insérées ; first et last sont les numéros de ligne des nouvelles lignes après leur insertion (premier et dernier numéro).

	Spécifie le premier et dernier numéro de ligne pour la liste de lignes que vous voulez insérer dans un élément du modèle. Comme présenté dans le diagramme, nous insérons trois lignes avant la ligne 2, donc le first vaut 2 et last vaut 4 : beginInsertRows(parent, 2, 4); Cela insère les trois nouvelles lignes aux positions 2, 3 et 4.
	Pour ajouter des lignes à la fin, insérez-les après la dernière ligne. Comme présenté dans le diagramme, nous rajoutons deux lignes à un ensemble de deux lignes déjà existantes (finissant à la ligne 3), donc first vaut 4 et last vaut 5 : beginInsertRows(parent, 4, 5); Cela ajoute les deux nouvelles lignes aux positions 4 et 5.

Note : cette fonction émet le signal rowsAboutToBeInserted() que les vues ou les proxy connectés doivent traiter avant l'insertion des données. Sinon, les vues pourront se trouver dans un état invalide.

Voir aussi endInsertRows().

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

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

Lors de la réimplémentation dans 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 d'index persistants dans le modèle, vous évitant de le faire par vous-même. L'utilisation de beginMoveRows et endMoveRows est une alternative à l'envoi de layoutAboutToBeChanged et layoutChanged directement avec changePersistentIndexes. Le signal layoutAboutToBeChanged est envoyé par cette méthode pour des raisons de compatibilité.

L'index sourceParent correspond au parent depuis lequel les colonnes sont déplacées. Les numéros de colonnes sourceFirst et sourceLast correspondent aux colonnes à déplacer. L'index destinationParent correspond au parent dans lequel les colonnes sont déplacées. Le numéro de colonne destinationChild est la colonne dans laquelle les colonnes seront déplacées. Ainsi, l'index de colonne sourceFirst dans sourceParent deviendra la colonne destinationChild dans destinationParent, suivie par les autres colonnes jusqu'à sourceLast.

Par contre, lors du déplacement des colonnes dans le même parent (si sourceParent et destinationParent sont identiques), les colonnes seront placées avant la colonne d'index destinationChild. Ainsi, si vous souhaitez déplacer les colonnes 0 et 1 pour qu'elles deviennent les colonnes 1 et 2, destinationChild devra être 3. Dans ce cas, le nouvel index pour la colonne source i (qui est compris entre sourceFirst et sourceLast) est égal à (destinationChild-sourceLast-1+i).

Notez que, si sourceParent et destinationParent sont identiques, destinationChild ne doit pas être compris entre sourceFirst et sourceLast + 1. Vous devez aussi vous assurer de ne pas essayer de déplacer une colonne dans l'un de ses propres enfants ou ancêtres. Cette méthode retourne false si l'une de ces conditions est vraie, dans ce cas vous devez annuler l'opération de déplacement.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi endMoveColumns().

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

Commence 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. Cette méthode est responsable du déplacement des index persistants dans le modèle, vous évitant de le faire par vous-même. L'utilisation de beginMoveRows et endMoveRows est une alternative à l'envoi des signaux layoutAboutToBeChanged et layoutChanged directement avec changePersistentIndexes. Le signal layoutAboutToBeChanged est envoyé par cette méthode pour des raisons de compatibilité.

L'index sourceParent correspond au parent depuis lequel les lignes sont déplacés ; Les numéros de lignes sourceFirst et sourceLast correspondent aux lignes à déplacer. L'index destinationParent correspond au parent dans lequel les lignes sont déplacées. Le numéro de ligne destinationChild est la ligne dans laquelle les lignes seront déplacées. Ainsi, l'index de ligne sourceFirst dans sourceParent deviendra la ligne destinationChild dans destinationParent, suivie par les autres lignes jusqu'à sourceLast.

Par contre, lors du déplacement des lignes dans le même parent (si sourceParent et destinationParent sont identiques), les lignes seront placées avant la ligne d'index destinationChild. Ainsi, si vous souhaitez déplacer les lignes 0 et 1 pour qu'elles deviennent les lignes 1 et 2, destinationChild devra être 3. Dans ce cas, le nouvel index pour la ligne source i (qui est compris entre sourceFirst et sourceLast) est égal à (destinationChild-sourceLast-1+i).

Notez que, si sourceParent et destinationParent sont identiques, destinationChild ne doit pas être compris entre sourceFirst et sourceLast + 1. Vous devez aussi vous assurer de ne pas essayer de déplacer une colonne dans l'un de ses propres enfants ou ancêtres. Cette méthode retourne false si l'une de ces conditions est vraie, dans ce cas vous devez annuler l'opération de déplacement.

	Spécifiez les numéros de la première et dernière ligne que vous voulez déplacer dans le modèle. destinationChild spécifie la ligne dans le parent de destination. Comme présenté dans le diagramme, nous déplaçons les trois lignes 2 à 4 de la source, donc sourceFirst vaut 2 et sourceLast vaut 4. Nous déplaçons ces éléments au-dessus de la ligne 2 dans la destination, donc destinationChild vaut 2. beginMoveRows(sourceParent, 2, 4, destinationParent, 2); Cela déplace les trois lignes 2, 3 et 4 de la source qui deviennent les lignes 2, 3 et 4 dans la destination. Les autres lignes affectées sont replacées en conséquence.
	Pour ajouter des lignes dans un autre parent, déplacez-les après la dernière ligne. Comme présenté dans le diagramme, nous déplaçons trois lignes dans un ensemble de 6 lignes existantes (finissant par la ligne 5), donc destinationChild vaut 6: beginMoveRows(sourceParent, 2, 4, destinationParent, 6); Cela déplace les lignes cibles à la fin du parent cible, aux positions 6, 7 et 8.
	Pour déplacer les lignes dans un même parent, spécifiez la ligne vers laquelle déplacer les éléments. Comme présenté dans le diagramme, nous déplaçons un élément de la ligne 2 à la ligne 0, donc sourceFirst et sourceLast valent 2 et destinationChild vaut 0. beginMoveRows(parent, 2, 2, parent, 0); Notez que les autres lignes peuvent être déplacées en conséquence. Notez aussi que lorsque vous déplacez des éléments d'un même parent, vous ne devez pas essayer de faire des déplacements invalides ou sur place. Dans l'exemple ci-dessus, l'élément 2 est à la ligne 2 avant le déplacement, donc il ne peut pas être déplacé à la ligne 2 (là où il est actuellement) ou à la ligne 3 (impossible car la ligne 3 signifie au-dessus de la ligne 3, où il est déjà).
	Pour déplacer des lignes dans un même parent, spécifiez la ligne vers laquelle vous voulez les déplacer. Comme présenté dans le diagramme, nous déplaçons un élément de la ligne 2 à la ligne 4, donc sourceFirst et sourceLast valent 2 et destinationChild vaut 4. beginMoveRows(parent, 2, 2, parent, 4); Notez que les autres lignes sont déplacées en conséquence.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi endMoveRows().

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

Démarre une opération de suppression de colonne.

Lors de la réimplementation de la fonction removeColumns() dans une sous-classe, vous devez appeler cette fonction avant la suppression des données dans le modèle sous-jacent.

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

Spécifie les index de la première et dernière colonne de l'intervalle des colonnes à supprimer de l'élément du modèle. Comme présenté dans le diagramme, nous retirons les trois colonnes entre la colonne 4 et 6, donc first vaut 4 et last vaut 6: beginRemoveColumns(parent, 4, 6);

Note : cette fonction envoie le signal columnsAboutToBeRemoved() que les vues ou proxy connectés doivent traiter avant la suppression des données. Sinon, les vues pourront se trouver dans un état invalide.

Voir aussi endRemoveColumns().

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

Démarre une opération de suppression de ligne.

Lors de la réimplémentation de la fonction removeRows() dans une sous-classe, vous devez appeler cette fonction avant la suppression des données dans le modèle sous-jacent.

L'index parent correspond au parent à partir duquel les lignes seront supprimées. Les numéros de lignes first et last correspondent à la première et à la dernière ligne à supprimer.

Spécifie les index de la première et dernière ligne de l'intervalle des lignes à supprimer d'un élément du modèle. Comme présenté dans le diagramme, nous retirons les deux lignes 2 et 3, donc first vaut 2 et last 3 : beginRemoveRows(parent, 2, 3);

Note : cette fonction envoie le signal rowsAboutToBeRemoved() que les vues ou proxy connectés doivent traiter avant la suppression des données. Sinon, les vues pourront se trouver dans un état invalide.

Voir aussi endRemoveRows().

void QAbstractItemModel::beginResetModel () [protected]

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

Une opération de réinitialisation réinitialise le modèle à son état actuel dans chacune des vues attachées.

Note : chaque vue attachée à ce modèle sera réinitialisée.

Lorsque le modèle est réinitialisé, cela signifie que toutes les données lues à partir du modèle sont maintenant invalides et doivent être récupérées une nouvelle fois. Cela signifie aussi que l'élément actuel ou les éléments sélectionnés deviendront invalides.

Lorsqu'un modèle change radicalement ses données et il peut être plus facile d'appeler simplement cette fonction plutôt que d'envoyer le signal dataChanged() pour informer les autres composants lorsque la source de données sous-jacentes, ou sa structure, a changé.

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi modelAboutToBeReset(), modelReset() et endResetModel().

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

Retourne un index du modèle pour le camarade de l'élément représenté par index. Lorsque l'utilisateur veut éditer un élément, la vue appellera cette fonction pour vérifier si c'est un autre élément du modèle qui doit être édité à sa place. La vue construira ensuite un délégué utilisant l'index de modèle retourné par l'élément camarade.

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

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

Retourne true s'il y a encore des données disponibles pour parent ; sinon retourne false.

L'implémentation par défaut retourne toujours true.

Si la fonction canFetchMore() retourne true, QAbstractItemView appellera la fonction fetchMore(). Cependant, la fonction fetchMore() est uniquement appelée lorsque le modèle est peuplé incrémentalement.

Voir aussi fetchMore().

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

Modifie le QPersistentModelIndex égal à l'index from donné en index to.

Si aucun index de modèle persistant égal à l'index from n'est trouvé, aucun changement n'est effectué.

Voir aussi persistentIndexList() et changePersistentIndexList().

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

Modifie les QPersistentModelIndex égaux aux index de la liste from en index de la liste to.

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

Cette fonction a été introduite dans Qt 4.1.

Voir aussi persistentIndexList() et changePersistentIndex().

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

Retourne le nombre de colonnes des enfants du parent donné.

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

Par exemple :

 int DomModel::columnCount(const QModelIndex &/*parent*/) const
 {
     return 3;
 }

Note : lors de la réimplémentation d'un modèle de table, la fonction columnCount() doit retourner 0 lorsque le parent est valide.

Voir aussi rowCount().

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

Le signal est envoyé juste avant que les colonnes soient insérées dans le modèle. Les nouveaux éléments seront positionnés entre le début start et la fin end inclus, dans l'élément parent donné.

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

Voir aussi insertColumns() et beginInsertColumns().

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

Ce signal est envoyé juste avant que les colonnes soient déplacées dans le modèle. Les éléments qui seront déplacés sont ceux situés entre sourceStart et sourceEnd inclus, dans l'élément sourceParent donné. Ils seront déplacés dans le parent de destination destinationParent à partir de la colonne destinationColumn.

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveRows().

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

Ce signal est envoyé juste avant que les colonnes soient retirées du modèle. Les éléments qui seront supprimés sont ceux situés entre start et end inclus, dans l'élément parent donné.

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

Voir aussi removeColumns() et beginRemoveColumns().

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

Ce signal est envoyé après que les colonnes sont insérées dans le modèle. Les nouveaux éléments sont ceux entre start et end inclus, dans l'élément parent parent.

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

Voir aussi insertColumns() et beginInsertColumns().

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

Ce signal est envoyé après que les colonnes sont déplacées dans le modèle. Les éléments entre sourceStart et sourceEnd inclus du parent sourceParent donné sont déplacés dans le destinationParent en partant de la colonne destinationColumn.

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveRows().

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

Ce signal est envoyé après que les colonnes sont supprimées du modèle. Les éléments qui seront supprimés sont ceux situés entre start et end inclus, dans l'élément parent donné.

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

Voir aussi removeColumns() et beginRemoveColumns().

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

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

Lors de l'utilisation d'un QSortFilterProxyModel, ses indices possèdent leurs propres pointeurs internes. Il n'est pas recommandé d'accéder à ces pointeurs en dehors du modèle. Utilisez la fonction data() à la place.

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

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

Crée un index de modèle pour la ligne row et la colonne column données avec l'identifiant interne id.

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

Voir aussi QModelIndex::internalId().

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

Retourne les données enregistrées pour le role donné pour l'élément référencé par index.

Note : si vous n'avez pas de valeur à renvoyer, retournez un QVariant invalide au lieu de renvoyer 0.

Voir aussi Qt::ItemDataRole, setData() et headerData().

void QAbstractItemModel::dataChanged ( const QModelIndex & topLeft, const QModelIndex & bottomRight ) [signal]

Ce signal est envoyé chaque fois que les données dans un élément existant sont modifiées.

Si les éléments ont le même parent, les éléments affecté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 envoyé explicitement.

Voir aussi headerDataChanged(), setData() et layoutChanged().

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

Traite les données data fournies par une opération de glisser-déposer qui s'est terminée par l'action spécifiée.

Retourne true si la donnée et l'action peuvent être gérées par le modèle ; sinon retourne false.

La ligne row, la colonne column et le parent spécifiés indiquent l'emplacement d'un élément dans le modèle où l'opération s'est terminée. Il est de la responsabilité du modèle de terminer l'action à l'emplacement correct.

Par exemple, une action de dépose sur un élément d'un QTreeView peut donner lieu à une insertion des éléments spécifiés par row, column et parent soit comme enfants, soit comme frères de l'élément.

Lorsque la ligne et la colonne valent -1 cela signifie qu'il est de la responsabilité du modèle de décider où placer les données. Cela peut arriver dans un arbre lorsque les données sont déposées dans le parent. Habituellement, les modèles ajouteront les données dans le parent.

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

void QAbstractItemModel::endInsertColumns () [protected]

Termine une opération d'insertion de colonnes.

Lors de la réimplémentation de la fonction insertColumns() dans une sous-classe, vous devez appeler cette fonction après l'insertion des données dans le modèle sous-jacent.

Voir aussi beginInsertColumns().

void QAbstractItemModel::endInsertRows () [protected]

Termine une opération d'insertion de lignes.

Lors de la réimplementation de la fonction insertRows() dans une sous-classe, vous devez appeler cette fonction après l'insertion des données dans le modèle sous-jacent.

Voir aussi beginInsertRows().

void QAbstractItemModel::endMoveColumns () [protected]

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

Lors de l'implémentation d'une sous-classe, vous devez appeler cette fonction après le déplacement des données dans le modèle sous-jacent.

Le signal layoutChanged est envoyé par cette méthode pour des raisons de compatibilité.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveColumns().

void QAbstractItemModel::endMoveRows () [protected]

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

Lors de l'implémentation d'une sous-classe, vous devez appeler cette fonction après le déplacement des données dans le modèle sous-jacent.

Le signal layoutChanged est envoyé par cette méthode pour des raisons de compatibilité.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveRows().

void QAbstractItemModel::endRemoveColumns () [protected]

Termine une opération de suppression de colonnes.

Lors de la réimplementation de la fonction removeColumns() dans une sous-classe, vous devez appeler cette fonction après la suppression des données dans le modèle sous-jacent.

Voir aussi beginRemoveColumns().

void QAbstractItemModel::endRemoveRows () [protected]

Termine l'opération de suppression de lignes.

Lors de la réimplémentation de la fonction removeRows() dans une sous-classe, vous devez appeler cette fonction après la suppression des données dans le modèle sous-jacent.

Voir aussi beginRemoveRows().

void QAbstractItemModel::endResetModel () [protected]

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

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginResetModel().

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

Récupère les données disponibles pour les éléments ayant pour parent l'index parent spécifié.

Réimplémentez cette fonction si vous peuplez le modèle incrémentalement.

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

Voir aussi canFetchMore().

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

Retourne les indicateurs pour l‹index donné.

L'implémentation de base retourne une combinaison d'indicateurs qui activent l'élément (ItemIsEnabled) et l'autorisent à être sélectionné (ItemIsSelectable).

Voir aussi Qt::ItemFlags.

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

Retourne true si parent possède des enfants ; sinon retourne false.

Utilisez la fonction rowCount() sur le parent pour trouver le nombre d'enfants.

Voir aussi parent() et index().

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

Retourne true si le modèle retourne un QModelIndex valide pour la ligne row et la colonne column avec parent, sinon retourne false.

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

Retourne les données de l'en-tête pour le role et la section donnés avec l‹orientation spécifiée.

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

Voir aussi Qt::ItemDataRole, setHeaderData() et QHeaderView.

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

Ce signal est envoyé chaque fois qu'un en-tête est modifiée. L'orientation indique si la modification concerne l'en-tête horizontal ou vertical. Les sections de l'en-tête comprises entre first et last doivent être mises à jour.

Lors de la réimplementation de la fonction setHeaderData(), ce signal doit être envoyé explicitement.

Si vous changez le nombre de colonnes ou de lignesv vous n'avez pas besoin d'envoyer ce signal, mais utilisez les fonctions begin/end (référez-vous à la section sur la dérivation dans la description de la classe QAbstractItemModel pour plus de détails).

Voir aussi headerData(), setHeaderData() et dataChanged().

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

Retourne l'index de l'élément du modèle spécifié par la ligne row, la colonne column et l'index parent.

Lors de la réimplémentation de cette fonction dans des classes dérivées, appelez createIndex() pour générer des index de modèle que les autres composants peuvent utiliser pour accéder aux éléments de votre modèle.

Voir aussi createIndex().

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

Insère une colonne unique avant la colonne column donnée en tant qu'enfant du parent spécifié.

Retourne true si la colonne est insérée ; sinon retourne false.

Voir aussi insertColumns(), insertRow() et removeColumn().

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

Sur les modèles qui le gèrent, cette fonction insère count nouvelles colonnes dans le modèle avant la colonne column donnée. Les éléments des nouvelles colonnes seront des enfants de l'élément représenté par l'index de modèle parent.

Si column est 0, les colonnes sont ajoutées avant les colonnes existantes.

Si column est columnCount(), les colonnes sont ajoutées après les colonnes existantes.

Si parent ne possède pas d'enfant, une ligne unique avec count colonnes est insérée.

Retourne true si l'insertion des colonnes a réussi ; sinon retourne false.

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

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez gérer les insertions. L?autre branche de l?alternative est de fournir votre propre API pour la modification des données.

Voir aussi insertRows(), removeColumns(), beginInsertColumns() et endInsertColumns().

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

Note : l'implémentation de la classe de base de cette fonction ne fait rien et retourne false.

Insère une ligne unique avant la ligne row donnée en tant qu'enfant de l'élément parent spécifié.

Retourne true si la ligne a été insérée ; sinon retourne false.

Voir aussi insertRows(), insertColumn() et removeRow().

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

Note : l'implémentation de la classe de base de cette fonction ne fait rien et retourne false.

Sur les modèles qui le gèrent, insère count lignes dans le modèle avant la ligne row. Les éléments des nouvelles lignes seront des enfants de l'élément ayant pour index de modèle parent.

Si row est 0, les lignes sont ajoutées avant les lignes du parent.

Si row est rowCount(), les lignes sont ajoutées après les lignes existantes du parent.

Si parent n'a pas d'enfant, une colonne avec count lignes est ajoutée.

Retourne true l'insertion a réussi ; sinon retourne false.

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez gérer les insertions. L'autre possibilité est de fournir votre propre API pour la modification des données. Dans tous les cas, vous devez appeler beginInsertRows() et endInsertRows() pour signaler aux autres composants que le modèle a été modifié.

Voir aussi insertColumns(), removeRows(), beginInsertRows() et endInsertRows().

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

Retourne une QMap contenant des valeurs pour tous les rôles prédéfinis du modèle pour l'élément correspondant à l‹index donné.

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

Voir aussi setItemData(), Qt::ItemDataRole et data().

void QAbstractItemModel::layoutAboutToBeChanged () [signal]

Ce signal est émis juste avant que la disposition du modèle soit modifiée. 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 modèles d'index persistants après l'envoi du signal layoutAboutToBeChanged().

Cette fonction a été introduite dans Qt 4.2.

Voir aussi layoutChanged() et changePersistentIndex().

void QAbstractItemModel::layoutChanged () [signal]

Ce signal est envoyé chaque fois que la disposition des éléments exposés par le modèle est modifiée, par exemple lorsque le modèle est trié. Lorsque ce signal est reçu par la vue, il doit mettre à jour la disposition des éléments pour refléter ce changement.

Lors de la dérivation de QAbstractItemModel ou QAbstractProxyModel, assurez-vous d'envoyer le signal layoutAboutToBeChanged() avant de changer l'ordre des éléments ou d'altérer la structure des données exposées aux vues et envoyez le signal layoutChanged() après le changement de la disposition.

Les sous-classes doivent mettre à jour tous les modèles d'index persistants avant l'envoi du signal layoutChanged(). Autrement dit, lorsque la structure est modifiée, l'ordre des opérations est le suivant :

• envoi du signal layoutAboutToBeChanged ;
• sauvegarde du QModelIndex modifié ;
• mise à jour de vos données internes ;
• appel de la fonction changePersistentIndex() ;
• envoi du signal layoutChanged.

Voir aussi layoutAboutToBeChanged(), dataChanged(), headerDataChanged(), modelReset() et changePersistentIndex().

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

Retourne une liste d'index des éléments de la colonne de l'index start pour lesquels les données stockées avec le rôle role correspondent à la valeur value spécifiée. La méthode de recherche est déterminée par les drapeaux flags donnés. La liste retournée peut être vide.

La recherche démarre à partir de l'index start et continue jusqu'à ce que le nombre d'éléments trouvés soit égal à hits, ou que la recherche atteigne la dernière ligne, qu'elle revienne sur l'index start - si l'indicateur MatchWrap est spécifié dans flags. Si vous souhaitez trouver tous les éléments correspondants, utilisez hits = -1.

Par défaut, cette fonction utilise une comparaison de chaîne de caractères sur tous les éléments, circulaire, recherchant les éléments commençant par value.

Note : l'implémentation par défaut de cette fonction ne recherche que dans une colonne. Reimplémentez cette fonction pour inclure un comportement de recherche différent.

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

Retourne un objet qui contient les données sérialisées des éléments correspondant à la liste indexes spécifiée. Le format utilisé pour décrire les données encodées est obtenu à partir de la fonction mimeTypes().

Si la liste d'index est vide ou si aucun type MIME n'est géré, la fonction renvoie 0 et non une liste vide sérialisée.

Voir aussi mimeTypes() et dropMimeData().

QStringList QAbstractItemModel::mimeTypes () const [virtual]

Retourne une liste de types MIME pouvant être utilisés pour décrire une liste d'index de modèle.

Voir aussi mimeData().

void QAbstractItemModel::modelAboutToBeReset () [signal]

Ce signal est envoyé lorsque la fonction reset() est appelée, avant que l'état interne du modèle (c'est-à-dire les index de modèles persistants) ne soit invalidé.

Cette fonction a été introduite dans Qt 4.2.

Voir aussi beginResetModel() et modelReset().

void QAbstractItemModel::modelReset () [signal]

Ce signal est envoyé lorsque la fonction reset() est appelée, après que l'état interne du modèle (c'est-à-dire les index de modèles persistants) est invalidé.

Cette fonction a été introduite dans Qt 4.1.

Voir aussi endResetModel() et modelAboutToBeReset().

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

Retourne le parent de l'élément du modèle ayant l‹index donné. Si l'élément n'a pas de parent, un QModelIndex invalide est retourné.

Une convention courante utilisée dans les modèles exposant des structures de données en arbre 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 du QModelIndex retourné devrait être 0.

Lors de la réimplémentation de cette fonction dans une sous-classe, évitez 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 produira une récursion infinie.

Voir aussi createIndex().

QModelIndexList QAbstractItemModel::persistentIndexList () const [protected]

Retourne la liste des index enregistrés comme index persistants dans le modèle.

Cette fonction a été introduite dans Qt 4.2.

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

Supprime la colonne column des éléments enfants du parent spécifié.

Retourne true si la colonne est supprimée ; sinon retourne false.

Voir aussi removeColumns(), removeRow() et insertColumn().

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

Pour les modèles qui le gèrent, supprime du modèle count colonnes à partir de la colonne column pour le parent parent.

Retourne true si les colonnes ont été supprimées ; sinon retourne false.

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

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez gérer la suppression. L'autre possibilité est de fournir votre propre API pour la modification des données.

Voir aussi removeColumn(), removeRows(), insertColumns(), beginRemoveColumns() et endRemoveColumns().

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

Supprime la ligne row des éléments enfants du parent parent spécifié.

Retourne true si la ligne est supprimée ; sinon retourne false.

Cette fonction est une fonction de commodité qui appelle removeRows(). L'implémentation de QAbstractItemModel de la fonction removeRows() ne fait rien.

Voir aussi removeRows(), removeColumn() et insertRow().

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

Sur les modèles qui le gèrent, supprime dans le modèle count lignes en partant de la ligne row dans le parent.

Retourne true si la suppression a réussi ; sinon retourne false.

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

Si vous implémentez votre propre modèle, vous pouvez réimplémenter cette fonction si vous souhaitez gérer la suppression. L'autre possibilité est de fournir votre propre API pour la modification des données.

Voir aussi removeRow(), removeColumns(), insertColumns(), beginRemoveRows() et endRemoveRows().

void QAbstractItemModel::reset () [protected]

Réinitialise le modèle à son état d'origine dans les vues attachées.

Note : utilisez les fonctions beginResetModel() et endResetModel() à chaque fois que possible. Utilisez cette méthode seulement s'il est impossible d'appeler la fonction beginResetModel() avant d'invalider le modèle. Sinon cela peut provoquer un comportement indéfini, surtout lors de l'utilisation de modèle proxy.

void QAbstractItemModel::revert () [virtual slot]

Indique au modèle qu'il doit oublier les informations mises en cache. Cette fonction est typiquement utilisée lors de l'édition de lignes.

Voir aussi submit().

const QHash<int, QByteArray> & QAbstractItemModel::roleNames () const

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

Cette fonction a été introduite dans Qt 4.6.

Voir aussi setRoleNames().

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

Retourne le nombre de lignes dans le parent donné. Lorsque le parent est valide, cela signifie que rowCount retourne le nombre d'enfants du parent.

Note : lors de l'implémentation d'un modèle basé sur une table, la fonction rowCount() devrait retourner 0 lorsque le parent est valide.

Voir aussi columnCount().

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

Ce signal est émis juste avant que les lignes ne soient insérées dans le modèle. Les nouveaux éléments seront positionnés entre start et end inclus, sous l'élément parent.

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 être émis explicitement par le code d'une sous-classe.

Voir aussi insertRows() et beginInsertRows().

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

Ce signal est émis avant que les lignes ne soient déplacées dans le modèle. Les éléments qui seront déplacés sont ceux compris entre sourceStart et sourceEnd inclus, sous l'élément parent sourceParent. Ils seront déplacés dans le parent 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 être émis explicitement par le code d'une sous-classe.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveRows().

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

Ce signal est envoyé juste avant que les lignes ne soient supprimées du modèle. Les éléments supprimés sont ceux compris entre start et end inclus, sous l'élément parent parent.

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 être émis explicitement par le code d'une sous-classe.

Voir aussi removeRows() et beginRemoveRows().

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

Ce signal est envoyé juste après que les lignes sont insérées dans le modèle. Les nouveaux éléments sont ceux compris entre start et end inclus, sous l'élément parent parent.

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 être émis explicitement par le code d'une sous-classe.

Voir aussi insertRows() et beginInsertRows().

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

Ce signal est envoyé après que les lignes sont déplacées dans le modèle. Les éléments entre sourceStart et sourceEnd inclus de l'élément parent sourceParent ont été déplacés dans le parent destinationParent à 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 être émis explicitement par le code d'une sous-classe.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi beginMoveRows().

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

Ce signal est envoyé après que les lignes sont supprimées du modèle. Les éléments supprimés sont ceux compris entre start et end inclus, sous l'élément parent parent.

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 être émis explicitement par le code d'une sous-classe.

Voir aussi removeRows() et beginRemoveRows().

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

Définit le role de la donnée pour l'élément à l'index index à la valeur value.

Retourne true en cas de réussite ; sinon retourne false.

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

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

Voir aussi Qt::ItemDataRole, data() et itemData().

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

Définit la donnée pour le role et la section donnés de l'entête ayant l‹orientation spécifiée à la valeur value fournie.

Retourne true si la donnée de l'en-tête a été mise à jour ; sinon retourne false.

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

Voir aussi Qt::ItemDataRole et headerData().

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

Définit les données de rôle pour l'élément à l'index index aux valeurs associées dans roles, pour chaque Qt::ItemDataRole.

Retourne true en cas de succès ; sinon retourne false.

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

Voir aussi setData(), data() et itemData().

void QAbstractItemModel::setRoleNames ( const QHash<int, QByteArray> & roleNames ) [protected]

Définit les noms de rôles du modèle à roleNames.

Cette fonction permet la correspondance entre les identifiants de rôle et les noms de propriétés de rôle dans les interfaces utilisateur déclaratives. Cette fonction doit être appelée avant d'utiliser le modèle. La modification des noms de rôles après que le modèle a été défini peut provoquer un comportement indéfini.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi roleNames().

void QAbstractItemModel::setSupportedDragActions ( Qt::DropActions actions )

Définit les actions de déplacement gérées pour les éléments dans le modèle.

Cette fonction a été introduite dans Qt 4.2.

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

QModelIndex QAbstractItemModel::sibling ( int row, int column, const QModelIndex & index ) const

Retourne les éléments de même niveau à la ligne row et la colonne column pour l'élément à l'index index ou un QModelIndex invalide s'il n'y a pas d'autres éléments à cet emplacement.

La fonction sibling() est simplement une fonction de commodité qui trouve le parent de l'élément et l'utilise pour récupérer l'index des éléments enfants dans la ligne row et la colonne column.

Voir aussi index(), QModelIndex::row() et QModelIndex::column().

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

Trie le modèle par la colonne column dans l'ordre order donné.

L'implémentation de base ne fait rien.

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

Retourne le nombre de lignes et de colonnes occupées par l'élément représenté par l'index index.

Note : actuellement, cette valeur n'est pas utilisée.

bool QAbstractItemModel::submit () [virtual slot]

Indique au modèle qu'il doit transférer les informations mises en cache vers l'enregistrement définitif. Cette fonction est typiquement utilisée pour l'édition des lignes.

Retourne true s'il n'y a pas d'erreur ; sinon retourne false.

Voir aussi revert().

Qt::DropActions QAbstractItemModel::supportedDragActions () const

Retourne les actions gérées par les données dans ce modèle.

L'implémentation par défaut retourne supportedDropActions() si aucune valeur spécifique n'a été définie avec la fonction setSupportedDragActions().

La fonction supportedDragActions() est utilisée par QAbstractItemView::startDrag() comme valeur par défaut lorsqu'un déplacement est effectué.

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

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

Retourne les actions de dépose gérées par ce modèle.

L'implémentation par défaut retourne Qt::CopyAction. Réimplémentez cette fonction si vous souhaitez gérer des actions supplémentaires. Vous pouvez aussi réimplémenter la fonction dropMimeData() pour gérer des opérations supplémentaires.

Cette fonction a été introduite dans Qt 4.2.

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

Remerciements

Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo et Claude Leloup pour la relecture !