QTableWidget Class

Documentation des fonctions membres

[explicit] QTableWidget::QTableWidget(QWidget *parent = nullptr)

Crée une nouvelle vue de table avec l'adresse parent.

QTableWidget::QTableWidget(int rows, int columns, QWidget *parent = nullptr)

Crée une nouvelle vue de table avec les données rows et columns, et avec la donnée parent.

[virtual noexcept] QTableWidget::~QTableWidget()

Détruit cette QTableWidget.

[signal] void QTableWidget::cellActivated(int row, int column)

Ce signal est émis lorsque la cellule spécifiée par row et column a été activée

[signal] void QTableWidget::cellChanged(int row, int column)

Ce signal est émis lorsque les données de l'élément dans la cellule spécifiée par row et column ont changé.

[signal] void QTableWidget::cellClicked(int row, int column)

Ce signal est émis chaque fois qu'une cellule du tableau est cliquée. Les adresses row et column spécifiées correspondent à la cellule sur laquelle on a cliqué.

[signal] void QTableWidget::cellDoubleClicked(int row, int column)

Ce signal est émis lorsqu'une cellule du tableau est doublement cliquée. Les adresses row et column spécifiées correspondent à la cellule qui a fait l'objet d'un double clic.

[signal] void QTableWidget::cellEntered(int row, int column)

Ce signal est émis lorsque le curseur de la souris entre dans une cellule. La cellule est spécifiée par row et column.

Ce signal n'est émis que lorsque le suivi de la souris est activé ou lorsqu'un bouton de la souris est enfoncé pendant que le curseur entre dans un élément.

[signal] void QTableWidget::cellPressed(int row, int column)

Ce signal est émis chaque fois qu'une cellule du tableau est pressée. Les valeurs row et column spécifiées correspondent à la cellule sur laquelle on a appuyé.

QWidget *QTableWidget::cellWidget(int row, int column) const

Renvoie le widget affiché dans la cellule dans les champs row et column.

Voir également setCellWidget().

[slot] void QTableWidget::clear()

Supprime tous les éléments de la vue. Cela supprimera également toutes les sélections et tous les en-têtes. Si vous ne souhaitez pas supprimer les en-têtes, utilisez QTableWidget::clearContents(). Les dimensions du tableau restent inchangées.

[slot] void QTableWidget::clearContents()

Supprime de la vue tous les éléments qui ne figurent pas dans les en-têtes. Toutes les sélections sont également supprimées. Les dimensions du tableau restent inchangées.

void QTableWidget::closePersistentEditor(QTableWidgetItem *item)

Ferme l'éditeur persistant pour item.

Voir aussi openPersistentEditor() et isPersistentEditorOpen().

int QTableWidget::column(const QTableWidgetItem *item) const

Renvoie la colonne de item.

int QTableWidget::columnCount() const

Renvoie le nombre de colonnes.

Voir également setColumnCount().

[signal] void QTableWidget::currentCellChanged(int currentRow, int currentColumn, int previousRow, int previousColumn)

Ce signal est émis chaque fois que la cellule courante change. La cellule spécifiée par previousRow et previousColumn est la cellule qui avait précédemment le focus, la cellule spécifiée par currentRow et currentColumn est la nouvelle cellule courante.

int QTableWidget::currentColumn() const

Renvoie la colonne de l'élément courant.

Voir aussi currentRow() et setCurrentCell().

QTableWidgetItem *QTableWidget::currentItem() const

Renvoie l'élément actuel.

Voir aussi setCurrentItem().

[signal] void QTableWidget::currentItemChanged(QTableWidgetItem *current, QTableWidgetItem *previous)

Ce signal est émis lorsque l'élément courant change. L'élément previous est l'élément qui avait précédemment le focus, current est le nouvel élément courant.

int QTableWidget::currentRow() const

Renvoie la ligne de l'élément actuel.

Voir aussi currentColumn() et setCurrentCell().

[override virtual protected] void QTableWidget::dropEvent(QDropEvent *event)

Réimplémente : QTableView::dropEvent(QDropEvent *event).

[virtual protected] bool QTableWidget::dropMimeData(int row, int column, const QMimeData *data, Qt::DropAction action)

Traite les data fournis par une opération de glisser-déposer qui s'est terminée par le action donné dans les row et column donnés. Renvoie true si les données et l'action peuvent être traitées par le modèle ; sinon, renvoie false.

Voir également supportedDropActions() et supportedDragActions.

void QTableWidget::editItem(QTableWidgetItem *item)

Commence à modifier le site item s'il est modifiable.

[override virtual protected] bool QTableWidget::event(QEvent *e)

Réimplémente : QAbstractItemView::event(QEvent *event).

QList<QTableWidgetItem *> QTableWidget::findItems(const QString &text, Qt::MatchFlags flags) const

Recherche les éléments qui correspondent à text à l'aide de flags.

QTableWidgetItem *QTableWidget::horizontalHeaderItem(int column) const

Renvoie l'élément d'en-tête horizontal de la colonne, column, si un tel élément a été défini ; sinon, renvoie nullptr.

Voir aussi setHorizontalHeaderItem().

QModelIndex QTableWidget::indexFromItem(const QTableWidgetItem *item) const

Retourne le QModelIndex associé au item donné.

[slot] void QTableWidget::insertColumn(int column)

Insère une colonne vide dans le tableau à l'adresse column.

[slot] void QTableWidget::insertRow(int row)

Insère une ligne vide dans le tableau à l'adresse row.

bool QTableWidget::isPersistentEditorOpen(QTableWidgetItem *item) const

Indique si un éditeur persistant est ouvert pour l'élément item.

Voir aussi openPersistentEditor() et closePersistentEditor().

QTableWidgetItem *QTableWidget::item(int row, int column) const

Renvoie l'élément correspondant à row et column si un élément a été défini ; sinon, renvoie nullptr.

Voir aussi setItem().

[signal] void QTableWidget::itemActivated(QTableWidgetItem *item)

Ce signal est émis lorsque l'adresse item spécifiée a été activée.

QTableWidgetItem *QTableWidget::itemAt(const QPoint &point) const

Renvoie un pointeur sur l'élément situé à l'adresse point, ou renvoie nullptr si point n'est pas couvert par un élément du widget table.

Voir aussi item().

QTableWidgetItem *QTableWidget::itemAt(int ax, int ay) const

Renvoie l'élément à la position équivalente à QPoint(ax, ay) dans le système de coordonnées du widget de table, ou renvoie nullptr si le point spécifié n'est pas couvert par un élément dans le widget de table.

Voir aussi item().

[signal] void QTableWidget::itemChanged(QTableWidgetItem *item)

Ce signal est émis lorsque les données de item ont changé.

[signal] void QTableWidget::itemClicked(QTableWidgetItem *item)

Ce signal est émis lorsqu'un élément du tableau est cliqué. L'adresse item spécifiée est l'élément sur lequel on a cliqué.

[signal] void QTableWidget::itemDoubleClicked(QTableWidgetItem *item)

Ce signal est émis lorsqu'un élément du tableau est doublement cliqué. L'adresse item spécifiée est l'élément qui a fait l'objet d'un double clic.

[signal] void QTableWidget::itemEntered(QTableWidgetItem *item)

Ce signal est émis lorsque le curseur de la souris entre dans un élément. L'adresse item correspond à l'élément saisi.

Ce signal n'est émis que lorsque le suivi de la souris est activé ou lorsqu'un bouton de la souris est enfoncé pendant que le curseur entre dans un élément.

QTableWidgetItem *QTableWidget::itemFromIndex(const QModelIndex &index) const

Renvoie un pointeur sur le site QTableWidgetItem associé au site index donné.

[signal] void QTableWidget::itemPressed(QTableWidgetItem *item)

Ce signal est émis lorsqu'un élément du tableau est pressé. L'adresse item spécifiée correspond à l'élément sur lequel on a appuyé.

const QTableWidgetItem *QTableWidget::itemPrototype() const

Renvoie le prototype de l'élément utilisé par la table.

Voir également setItemPrototype().

[signal] void QTableWidget::itemSelectionChanged()

Ce signal est émis lorsque la sélection change.

Voir aussi selectedItems() et QTableWidgetItem::isSelected().

QList<QTableWidgetItem *> QTableWidget::items(const QMimeData *data) const

Renvoie une liste de pointeurs vers les éléments contenus dans l'objet data. Si l'objet n'a pas été créé par un QTreeWidget dans le même processus, la liste est vide.

[virtual protected] QMimeData *QTableWidget::mimeData(const QList<QTableWidgetItem *> &items) const

Renvoie un objet qui contient une description sérialisée de l'élément spécifié items. Le format utilisé pour décrire les éléments est obtenu à partir de la fonction mimeTypes().

Si la liste des éléments est vide, nullptr est renvoyé au lieu d'une liste vide sérialisée.

[virtual protected] QStringList QTableWidget::mimeTypes() const

Renvoie une liste de types MIME pouvant être utilisés pour décrire une liste d'éléments de tablewidget.

Voir également mimeData().

void QTableWidget::openPersistentEditor(QTableWidgetItem *item)

Ouvre un éditeur pour le fichier item. L'éditeur reste ouvert après l'édition.

Voir aussi closePersistentEditor() et isPersistentEditorOpen().

void QTableWidget::removeCellWidget(int row, int column)

Supprime le widget placé sur la cellule indiquée par row et column.

[slot] void QTableWidget::removeColumn(int column)

Supprime la colonne column et tous ses éléments du tableau.

[slot] void QTableWidget::removeRow(int row)

Supprime la ligne row et tous ses éléments du tableau.

int QTableWidget::row(const QTableWidgetItem *item) const

Renvoie la ligne correspondant à item.

int QTableWidget::rowCount() const

Renvoie le nombre de lignes.

Voir également setRowCount().

[slot] void QTableWidget::scrollToItem(const QTableWidgetItem *item, QAbstractItemView::ScrollHint hint = EnsureVisible)

Fait défiler la vue si nécessaire pour s'assurer que le site item est visible. Le paramètre hint spécifie plus précisément l'emplacement de item après l'opération.

QList<QTableWidgetItem *> QTableWidget::selectedItems() const

Renvoie une liste de tous les éléments sélectionnés.

Cette fonction renvoie une liste de pointeurs sur le contenu des cellules sélectionnées. Utilisez la fonction selectedIndexes() pour récupérer la sélection complète , y compris les cellules vides.

Voir aussi selectedIndexes().

QList<QTableWidgetSelectionRange> QTableWidget::selectedRanges() const

Renvoie une liste de toutes les plages sélectionnées.

Voir aussi QTableWidgetSelectionRange.

void QTableWidget::setCellWidget(int row, int column, QWidget *widget)

Définit l'affichage de la cellule widget dans les cellules row et column, en transmettant la propriété du widget à la table.

Si le widget de cellule A est remplacé par le widget de cellule B, le widget de cellule A sera supprimé. Par exemple, dans l'extrait de code ci-dessous, l'objet QLineEdit sera supprimé.

setCellWidget(row, column, new QLineEdit);
...
setCellWidget(row, column, new QTextEdit);

Voir également cellWidget().

void QTableWidget::setColumnCount(int columns)

Définit le nombre de colonnes dans le modèle de cette table à columns. Si ce nombre est inférieur à columnCount(), les données des colonnes non désirées sont supprimées.

Voir également columnCount() et setRowCount().

void QTableWidget::setCurrentCell(int row, int column)

Définit la cellule actuelle comme étant la cellule à la position (row, column).

En fonction de l'état actuel de selection mode, la cellule peut également être sélectionnée.

Voir également setCurrentItem(), currentRow() et currentColumn().

void QTableWidget::setCurrentCell(int row, int column, QItemSelectionModel::SelectionFlags command)

Définit la cellule actuelle comme étant la cellule à la position (row, column), en utilisant la donnée command.

Voir aussi setCurrentItem(), currentRow() et currentColumn().

void QTableWidget::setCurrentItem(QTableWidgetItem *item)

Définit l'élément actuel sur item.

Si le mode de sélection n'est pas NoSelection, l'élément est également sélectionné.

Voir également currentItem() et setCurrentCell().

void QTableWidget::setCurrentItem(QTableWidgetItem *item, QItemSelectionModel::SelectionFlags command)

Définit l'élément en cours comme étant item, en utilisant l'adresse command.

Voir aussi currentItem() et setCurrentCell().

void QTableWidget::setHorizontalHeaderItem(int column, QTableWidgetItem *item)

Définit l'élément d'en-tête horizontal pour la colonne column à item. Si nécessaire, le nombre de colonnes est augmenté pour s'adapter à l'élément. L'élément d'en-tête précédent (s'il y en avait un) est supprimé.

Voir également horizontalHeaderItem().

void QTableWidget::setHorizontalHeaderLabels(const QStringList &labels)

Définit les étiquettes d'en-tête horizontales à l'aide de labels.

void QTableWidget::setItem(int row, int column, QTableWidgetItem *item)

Définit l'élément pour les données row et column à item.

Le tableau devient propriétaire de l'élément.

Notez que si le tri est activé (voir sortingEnabled) et que column est la colonne de tri actuelle, row sera déplacé vers la position de tri déterminée par item.

Si vous souhaitez définir plusieurs éléments d'une ligne particulière (par exemple, en appelant setItem() dans une boucle), vous pouvez désactiver le tri avant de le faire, et le réactiver après ; cela vous permettra d'utiliser le même argument row pour tous les éléments de la même ligne (c'est-à-dire que setItem() ne déplacera pas la ligne).

Voir également item() et takeItem().

void QTableWidget::setItemPrototype(const QTableWidgetItem *item)

Définit le prototype de l'élément du tableau à l'adresse item spécifiée.

Le widget de tableau utilisera la fonction de clonage du prototype d'élément lorsqu'il devra créer un nouvel élément de tableau. Par exemple, lorsque l'utilisateur modifie une cellule vide. Cette fonction est utile lorsque vous avez une sous-classe QTableWidgetItem et que vous voulez vous assurer que QTableWidget crée des instances de votre sous-classe.

Le tableau devient propriétaire du prototype.

Voir également itemPrototype().

void QTableWidget::setRangeSelected(const QTableWidgetSelectionRange &range, bool select)

Sélectionne ou désélectionne le site range en fonction de select.

void QTableWidget::setRowCount(int rows)

Définit le nombre de lignes du modèle de cette table à rows. Si ce nombre est inférieur à rowCount(), les données des lignes non désirées sont supprimées.

Voir également rowCount() et setColumnCount().

void QTableWidget::setVerticalHeaderItem(int row, QTableWidgetItem *item)

Définit l'élément d'en-tête vertical pour la ligne row à item.

Voir aussi verticalHeaderItem().

void QTableWidget::setVerticalHeaderLabels(const QStringList &labels)

Définit les étiquettes d'en-tête verticales à l'aide de labels.

void QTableWidget::sortItems(int column, Qt::SortOrder order = Qt::AscendingOrder)

Trie toutes les lignes du widget table en fonction de column et order.

[virtual protected] Qt::DropActions QTableWidget::supportedDropActions() const

Renvoie les actions de dépôt prises en charge par cette vue.

Voir aussi Qt::DropActions, supportedDragActions, et dropMimeData().

QTableWidgetItem *QTableWidget::takeHorizontalHeaderItem(int column)

Retire de l'en-tête l'élément d'en-tête horizontal situé à l'adresse column sans le supprimer.

QTableWidgetItem *QTableWidget::takeItem(int row, int column)

Retire du tableau l'élément situé à row et column sans le supprimer.

QTableWidgetItem *QTableWidget::takeVerticalHeaderItem(int row)

Supprime l'élément d'en-tête vertical à l'adresse row de l'en-tête sans l'effacer.

QTableWidgetItem *QTableWidget::verticalHeaderItem(int row) const

Renvoie l'élément d'en-tête vertical pour la ligne row.

Voir aussi setVerticalHeaderItem().

int QTableWidget::visualColumn(int logicalColumn) const

Renvoie la colonne visuelle de logicalColumn.

QRect QTableWidget::visualItemRect(const QTableWidgetItem *item) const

Renvoie le rectangle de la fenêtre de visualisation occupé par l'élément à l'adresse item.

int QTableWidget::visualRow(int logicalRow) const

Renvoie la ligne visuelle de l'adresse logicalRow.