QHeaderView Class

Documentation des fonctions membres

[explicit] QHeaderView::QHeaderView(Qt::Orientation orientation, QWidget *parent = nullptr)

Crée un nouvel en-tête générique avec les données orientation et parent.

[virtual noexcept] QHeaderView::~QHeaderView()

Détruit l'en-tête.

int QHeaderView::count() const

Renvoie le nombre de sections dans l'en-tête.

Voir aussi sectionCountChanged() et length().

[override virtual protected] void QHeaderView::currentChanged(const QModelIndex &current, const QModelIndex &old)

Réimplémente : QAbstractItemView::currentChanged(const QModelIndex &current, const QModelIndex &previous).

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

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

[signal] void QHeaderView::geometriesChanged()

Ce signal est émis lorsque les géométries de l'en-tête ont changé.

[slot] void QHeaderView::headerDataChanged(Qt::Orientation orientation, int logicalFirst, int logicalLast)

Met à jour les sections d'en-tête modifiées avec l'adresse orientation, de logicalFirst à logicalLast inclus.

int QHeaderView::hiddenSectionCount() const

Renvoie le nombre de sections de l'en-tête qui ont été cachées.

Voir aussi setSectionHidden() et isSectionHidden().

void QHeaderView::hideSection(int logicalIndex)

Cache la section spécifiée par logicalIndex.

Voir aussi showSection(), isSectionHidden(), hiddenSectionCount() et setSectionHidden().

[override virtual protected] int QHeaderView::horizontalOffset() const

Réimplémente : QAbstractItemView::horizontalOffset() const.

Renvoie le décalage horizontal de l'en-tête. La valeur est de 0 pour les en-têtes verticaux.

Voir aussi offset().

[virtual protected] void QHeaderView::initStyleOption(QStyleOptionHeader *option) const

Initialiser option avec les valeurs de ce QHeaderView. Cette méthode est utile pour les sous-classes qui ont besoin d'un QStyleOptionHeader, mais qui ne veulent pas remplir toutes les informations elles-mêmes.

Voir aussi QStyleOption::initFrom() et initStyleOptionForIndex().

[virtual protected, since 6.0] void QHeaderView::initStyleOptionForIndex(QStyleOptionHeader *option, int logicalIndex) const

Initialise le style option à partir du style logicalIndex spécifié. Cette fonction est appelée par l'implémentation par défaut de paintSection après que initStyleOption a été appelé.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi paintSection() et initStyleOption().

bool QHeaderView::isSectionHidden(int logicalIndex) const

Renvoie true si la section spécifiée par logicalIndex est explicitement cachée à l'utilisateur ; sinon, renvoie false.

Voir aussi hideSection(), showSection(), setSectionHidden() et hiddenSectionCount().

int QHeaderView::length() const

Renvoie la longueur de l'orientation de l'en-tête.

Voir aussi sizeHint(), setSectionResizeMode(), et offset().

int QHeaderView::logicalIndex(int visualIndex) const

Renvoie l'indice logique de la section à la position visualIndex donnée, ou -1 si visualIndex < 0 ou visualIndex >= QHeaderView::count().

Notez que visualIndex n'est pas affecté par les sections cachées.

Voir aussi visualIndex() et sectionPosition().

int QHeaderView::logicalIndexAt(const QPoint &pos) const

Renvoie l'index logique de la section à la position indiquée dans pos. Si l'en-tête est horizontal, la coordonnée x sera utilisée, sinon la coordonnée y sera utilisée pour trouver l'index logique.

Voir aussi sectionPosition().

int QHeaderView::logicalIndexAt(int position) const

Renvoie la section qui couvre le site position dans la fenêtre de visualisation.

Voir aussi visualIndexAt() et isSectionHidden().

int QHeaderView::logicalIndexAt(int x, int y) const

Renvoie l'index logique de la section à la coordonnée donnée. Si l'en-tête est horizontal, x sera utilisé, sinon y sera utilisé pour trouver l'index logique.

[override virtual protected] void QHeaderView::mouseDoubleClickEvent(QMouseEvent *e)

Réimplémente : QAbstractItemView::mouseDoubleClickEvent(QMouseEvent *event).

[override virtual protected] void QHeaderView::mouseMoveEvent(QMouseEvent *e)

Réimplémente : QAbstractItemView::mouseMoveEvent(QMouseEvent *event).

[override virtual protected] void QHeaderView::mousePressEvent(QMouseEvent *e)

Réimplémente : QAbstractItemView::mousePressEvent(QMouseEvent *event).

[override virtual protected] void QHeaderView::mouseReleaseEvent(QMouseEvent *e)

Réimplémente : QAbstractItemView::mouseReleaseEvent(QMouseEvent *event).

void QHeaderView::moveSection(int from, int to)

Déplace la section à l'index visuel from pour occuper l'index visuel to.

Voir aussi sectionsMoved().

int QHeaderView::offset() const

Renvoie le décalage de l'en-tête : il s'agit du pixel visible le plus à gauche (ou le plus en haut pour les en-têtes verticaux) de l'en-tête.

Voir aussi setOffset().

Qt::Orientation QHeaderView::orientation() const

Renvoie l'orientation de l'en-tête.

Voir aussi Qt::Orientation.

[override virtual protected] void QHeaderView::paintEvent(QPaintEvent *e)

Réimplémente : QAbstractScrollArea::paintEvent(QPaintEvent *event).

[virtual protected] void QHeaderView::paintSection(QPainter *painter, const QRect &rect, int logicalIndex) const

Peint la section spécifiée par l'adresse logicalIndex, en utilisant les adresses painter et rect.

Normalement, il n'est pas nécessaire d'appeler cette fonction.

[override virtual] void QHeaderView::reset()

Réimplémente : QAbstractItemView::reset().

int QHeaderView::resizeContentsPrecision() const

Renvoie le degré de précision du calcul de QHeaderView sur ResizeToContents.

Voir aussi setResizeContentsPrecision() et setSectionResizeMode().

void QHeaderView::resizeSection(int logicalIndex, int size)

Redimensionne la section spécifiée par logicalIndex à size en pixels. Le paramètre size doit avoir une valeur supérieure ou égale à zéro. Une taille égale à zéro n'est cependant pas recommandée. Dans ce cas, il convient d'utiliser hideSection.

Voir aussi sectionResized(), sectionSize() et hideSection().

[protected slot] void QHeaderView::resizeSections()

Redimensionne les sections en fonction de leurs indices de taille. Normalement, il n'est pas nécessaire d'appeler cette fonction.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        headerView, qOverload<>(&QHeaderView::resizeSections));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        headerView, [receiver = headerView]() { receiver->resizeSections(); });

void QHeaderView::resizeSections(QHeaderView::ResizeMode mode)

Redimensionne les sections en fonction de l'adresse mode, en ignorant le mode de redimensionnement actuel.

Voir aussi sectionResized().

bool QHeaderView::restoreState(const QByteArray &state)

Restaure le site state de cette vue d'en-tête. Cette fonction renvoie true si l'état a été restauré, sinon elle renvoie false.

Voir aussi saveState().

QByteArray QHeaderView::saveState() const

Sauvegarde l'état actuel de cette vue d'en-tête.

Pour restaurer l'état sauvegardé, passez la valeur de retour à restoreState().

Voir aussi restoreState().

[signal] void QHeaderView::sectionClicked(int logicalIndex)

Ce signal est émis lorsqu'une section est cliquée. L'index logique de la section est spécifié par logicalIndex.

Notez que le signal sectionPressed sera également émis.

Voir aussi setSectionsClickable() et sectionPressed().

[signal] void QHeaderView::sectionCountChanged(int oldCount, int newCount)

Ce signal est émis lorsque le nombre de sections change, c'est-à-dire lorsque des sections sont ajoutées ou supprimées. Le nombre initial est spécifié par oldCount, et le nouveau nombre par newCount.

Voir également count(), length() et headerDataChanged().

[signal] void QHeaderView::sectionDoubleClicked(int logicalIndex)

Ce signal est émis lorsqu'une section est double-cliquée. L'index logique de la section est spécifié par logicalIndex.

Voir aussi setSectionsClickable().

[signal] void QHeaderView::sectionEntered(int logicalIndex)

Ce signal est émis lorsque le curseur se déplace sur la section et que le bouton gauche de la souris est enfoncé. L'index logique de la section est spécifié par logicalIndex.

Voir aussi setSectionsClickable() et sectionPressed().

[signal] void QHeaderView::sectionHandleDoubleClicked(int logicalIndex)

Ce signal est émis lorsqu'une section est double-cliquée. L'index logique de la section est spécifié par logicalIndex.

Voir aussi setSectionsClickable().

[signal] void QHeaderView::sectionMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)

Ce signal est émis lorsqu'une section est déplacée. L'index logique de la section est spécifié par logicalIndex, l'ancien index par oldVisualIndex, et la nouvelle position d'index par newVisualIndex.

Voir aussi moveSection().

int QHeaderView::sectionPosition(int logicalIndex) const

Renvoie la position de la section du site logicalIndex, ou -1 si la section est cachée. La position est mesurée en pixels à partir du coin supérieur gauche du premier élément visible jusqu'au coin supérieur gauche de l'élément avec logicalIndex. La mesure se fait sur l'axe des x pour les en-têtes horizontaux et sur l'axe des y pour les en-têtes verticaux.

Voir également sectionViewportPosition().

[signal] void QHeaderView::sectionPressed(int logicalIndex)

Ce signal est émis lorsqu'une section est pressée. L'index logique de la section est spécifié par logicalIndex.

Voir aussi setSectionsClickable().

QHeaderView::ResizeMode QHeaderView::sectionResizeMode(int logicalIndex) const

Renvoie le mode de redimensionnement qui s'applique à la section spécifiée par l'adresse logicalIndex.

Voir aussi setSectionResizeMode().

[signal] void QHeaderView::sectionResized(int logicalIndex, int oldSize, int newSize)

Ce signal est émis lorsqu'une section est redimensionnée. Le numéro logique de la section est spécifié par logicalIndex, l'ancienne taille par oldSize, et la nouvelle taille par newSize.

Voir aussi resizeSection().

int QHeaderView::sectionSize(int logicalIndex) const

Renvoie la largeur (ou la hauteur pour les en-têtes verticaux) de la page logicalIndex.

Voir aussi length(), setSectionResizeMode(), et defaultSectionSize().

[virtual protected] QSize QHeaderView::sectionSizeFromContents(int logicalIndex) const

Renvoie la taille du contenu de la section spécifiée par l'adresse logicalIndex.

Voir aussi defaultSectionSize().

int QHeaderView::sectionSizeHint(int logicalIndex) const

Renvoie un indice de taille approprié pour la section spécifiée par logicalIndex.

Qt::SizeHintRole

Voir aussi sizeHint(), defaultSectionSize(), minimumSectionSize(), et maximumSectionSize().

int QHeaderView::sectionViewportPosition(int logicalIndex) const

Renvoie la position de la section dans la fenêtre de visualisation de l'adresse logicalIndex.

Si la section est cachée, la valeur retournée est indéfinie.

Voir aussi sectionPosition() et isSectionHidden().

[protected slot] void QHeaderView::sectionsAboutToBeRemoved(const QModelIndex &parent, int logicalFirst, int logicalLast)

Ce slot est appelé lorsque des sections sont supprimées du site parent. logicalFirst et logicalLast indiquent l'endroit où les sections ont été supprimées.

Si une seule section est supprimée, logicalFirst et logicalLast seront identiques.

bool QHeaderView::sectionsClickable() const

Renvoie sectionsClickable.

Voir également setSectionsClickable().

bool QHeaderView::sectionsHidden() const

Renvoie true si des sections de l'en-tête ont été cachées ; sinon, renvoie false ;

Voir aussi setSectionHidden().

[protected slot] void QHeaderView::sectionsInserted(const QModelIndex &parent, int logicalFirst, int logicalLast)

Ce slot est appelé lorsque des sections sont insérées dans le site parent. Les indices logicalFirst et logicalLast indiquent l'endroit où les nouvelles sections ont été insérées.

Si une seule section est insérée, logicalFirst et logicalLast seront identiques.

bool QHeaderView::sectionsMovable() const

Renvoie sectionsMovable.

Voir également setSectionsMovable().

bool QHeaderView::sectionsMoved() const

Renvoie true si des sections de l'en-tête ont été déplacées ; sinon, renvoie false ;

Voir aussi moveSection().

[override virtual] void QHeaderView::setModel(QAbstractItemModel *model)

Réimplémente : QAbstractItemView::setModel(QAbstractItemModel *model).

[slot] void QHeaderView::setOffset(int offset)

Fixe le décalage de l'en-tête à offset.

Voir aussi offset() et length().

[slot] void QHeaderView::setOffsetToLastSection()

Définit le décalage pour que la dernière section soit visible.

Voir aussi setOffset(), sectionPosition() et setOffsetToSectionPosition().

[slot] void QHeaderView::setOffsetToSectionPosition(int visualSectionNumber)

Définit le décalage par rapport au début de la section à l'adresse visualSectionNumber. visualSectionNumber est la section visible réelle lorsque les hiddenSections ne sont pas prises en compte. Ce n'est pas toujours la même chose que visualIndex().

Voir également setOffset() et sectionPosition().

void QHeaderView::setResizeContentsPrecision(int precision)

Définit la précision avec laquelle QHeaderView doit calculer la taille lorsque ResizeToContents est utilisé. Une valeur faible permet un redimensionnement automatique moins précis mais rapide, tandis qu'une valeur élevée permet un redimensionnement plus précis, mais qui peut être lent.

Le nombre precision indique le nombre de sections à prendre en compte dans le calcul de la taille préférée.

La valeur par défaut est 1000, ce qui signifie qu'une colonne horizontale avec redimensionnement automatique prendra en compte un maximum de 1000 lignes lors du calcul du redimensionnement automatique.

La valeur spéciale 0 signifie que seule la zone visible sera prise en compte. La valeur spéciale -1 implique l'examen de tous les éléments.

Cette valeur est utilisée dans QTableView::sizeHintForColumn(), QTableView::sizeHintForRow() et QTreeView::sizeHintForColumn(). La réimplémentation de ces fonctions peut faire en sorte que cette fonction n'ait pas d'effet.

Voir aussi resizeContentsPrecision(), setSectionResizeMode(), resizeSections(), QTableView::sizeHintForColumn(), QTableView::sizeHintForRow() et QTreeView::sizeHintForColumn().

void QHeaderView::setSectionHidden(int logicalIndex, bool hide)

Si hide est vrai, la section spécifiée par logicalIndex est cachée ; sinon, la section est affichée.

Voir aussi isSectionHidden() et hiddenSectionCount().

void QHeaderView::setSectionResizeMode(QHeaderView::ResizeMode mode)

Fixe les contraintes de redimensionnement de l'en-tête à celles décrites par l'adresse mode.

Voir aussi sectionResizeMode(), length(), et sectionResized().

void QHeaderView::setSectionResizeMode(int logicalIndex, QHeaderView::ResizeMode mode)

Définit les contraintes sur la manière dont la section spécifiée par logicalIndex dans l'en-tête peut être redimensionnée en fonction de celles décrites par mode. L'index logique doit exister au moment où cette fonction est appelée.

Voir également setStretchLastSection() et resizeContentsPrecision().

void QHeaderView::setSectionsClickable(bool clickable)

Remplacer sectionsClickable par clickable.

Voir aussi sectionsClickable().

void QHeaderView::setSectionsMovable(bool movable)

Remplace sectionsMovable par movable.

Voir aussi sectionsMovable().

[override virtual protected] void QHeaderView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags flags)

Réimplémente : QAbstractItemView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags flags).

Sélectionne les éléments de l'adresse rect donnée en fonction de l'adresse flags spécifiée.

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

void QHeaderView::setSortIndicator(int logicalIndex, Qt::SortOrder order)

Définit l'indicateur de tri pour la section spécifiée par logicalIndex dans la direction spécifiée par order, et supprime l'indicateur de tri de toute autre section qui l'affichait.

logicalIndex peut être -1, auquel cas aucun indicateur de tri ne sera affiché et le modèle reviendra à son ordre naturel, non trié. Notez que tous les modèles ne supportent pas cela et peuvent même se bloquer dans ce cas.

Voir également sortIndicatorSection() et sortIndicatorOrder().

[override virtual] void QHeaderView::setVisible(bool v)

Réimplémente une fonction d'accès à la propriété : QWidget::visible.

void QHeaderView::showSection(int logicalIndex)

Affiche la section spécifiée par logicalIndex.

Voir aussi hideSection(), isSectionHidden(), hiddenSectionCount() et setSectionHidden().

[override virtual] QSize QHeaderView::sizeHint() const

Réimplémente : QAbstractScrollArea::sizeHint() const.

Renvoie un indice de taille approprié pour cet en-tête.

Voir aussi sectionSizeHint().

[signal] void QHeaderView::sortIndicatorChanged(int logicalIndex, Qt::SortOrder order)

Ce signal est émis lorsque la section contenant l'indicateur de tri ou l'ordre indiqué est modifié. L'index logique de la section est spécifié par logicalIndex et l'ordre de tri est spécifié par order.

Voir aussi setSortIndicator().

Qt::SortOrder QHeaderView::sortIndicatorOrder() const

Renvoie l'ordre de l'indicateur de tri. Si aucune section n'a d'indicateur de tri, la valeur de retour de cette fonction est indéfinie.

Voir aussi setSortIndicator() et sortIndicatorSection().

int QHeaderView::sortIndicatorSection() const

Renvoie l'index logique de la section qui possède un indicateur de tri. Par défaut, il s'agit de la section 0.

Voir aussi setSortIndicator(), sortIndicatorOrder() et setSortIndicatorShown().

int QHeaderView::stretchSectionCount() const

Renvoie le nombre de sections qui sont définies en mode de redimensionnement par étirement. Dans les vues, cela peut être utilisé pour voir si la vue d'en-tête doit redimensionner les sections lorsque la géométrie de la vue change.

Voir également stretchLastSection.

void QHeaderView::swapSections(int first, int second)

Remplace la section à l'indice visuel first par la section à l'indice visuel second.

Voir aussi moveSection().

[override virtual protected] int QHeaderView::verticalOffset() const

Réimplémente : QAbstractItemView::verticalOffset() const.

Renvoie le décalage vertical de l'en-tête. Il est égal à 0 pour les en-têtes horizontaux.

Voir aussi offset().

[override virtual protected] bool QHeaderView::viewportEvent(QEvent *e)

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

int QHeaderView::visualIndex(int logicalIndex) const

Renvoie la position de l'indice visuel de la section spécifiée par l'adresse logicalIndex, ou -1 dans le cas contraire.

Les sections cachées ont toujours des index visuels valides.

Voir aussi logicalIndex().

int QHeaderView::visualIndexAt(int position) const

Renvoie l'indice visuel de la section qui couvre l'adresse position dans la fenêtre de visualisation.

Voir aussi logicalIndexAt().