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 valeurs indiquées pour les paramètres « orientation » et « parent ».

[virtual noexcept] QHeaderView::~QHeaderView()

Supprime l'en-tête.

int QHeaderView::count() const

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

Voir également 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'orientation ion fournie, de logicalFirst à logicalLast inclus.

int QHeaderView::hiddenSectionCount() const

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

Voir également setSectionHidden() et isSectionHidden().

void QHeaderView::hideSection(int logicalIndex)

Masque la section spécifiée par logicalIndex.

Voir également 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. Cette valeur est égale à 0 pour les en-têtes verticaux.

Voir aussi offset().

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

Initialisez ` option ` avec les valeurs fournies à l'adresse QHeaderView. Cette méthode est utile pour les sous-classes qui ont besoin d'un ` QStyleOptionHeader`, mais ne souhaitent pas renseigner elles-mêmes toutes les informations.

Voir également QStyleOption::initFrom() et initStyleOptionForIndex().

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

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

Cette fonction a été introduite dans Qt 6.0.

Voir également paintSection() et initStyleOption().

bool QHeaderView::isSectionHidden(int logicalIndex) const

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

Voir également hideSection(), showSection(), setSectionHidden() et hiddenSectionCount().

int QHeaderView::length() const

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

Voir également sizeHint(), setSectionResizeMode() et offset().

int QHeaderView::logicalIndex(int visualIndex) const

Renvoie l'index logique de la section située à la position indiquée par ` visualIndex `, ou -1 si ` visualIndex ` < 0 ou si ` visualIndex ` >= ` QHeaderView::count()`.

Notez que l'visualIndex n'est pas affectée par les sections masquées.

Voir également visualIndex() et sectionPosition().

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

Renvoie l'index logique de la section située à la position indiquée dans pos. Si l'en-tête est horizontale, c'est la coordonnée x qui sera utilisée ; dans le cas contraire, c'est la coordonnée y qui servira à déterminer l'index logique.

Voir aussi sectionPosition().

int QHeaderView::logicalIndexAt(int position) const

Renvoie la section de la fenêtre d'affichage qui recouvre l'position e spécifiée.

Voir également ` visualIndexAt()` et ` isSectionHidden()`.

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

Renvoie l'index logique de la section située à la coordonnée indiquée. Si l'en-tête est horizontale, on utilisera ` x ` ; dans le cas contraire, on utilisera ` y ` pour déterminer 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 située à l'index visuel from pour qu'elle occupe l'index visuel to.

Voir également 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'logicalIndex donné, en utilisant les paramètres painter et rect fournis.

En règle générale, vous n'avez pas besoin d'appeler cette fonction.

[override virtual] void QHeaderView::reset()

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

int QHeaderView::resizeContentsPrecision() const

Renvoie le niveau de précision avec lequel ` QHeaderView ` effectuera le calcul sur ` ResizeToContents`.

Voir également 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 être une valeur supérieure ou égale à zéro. Une taille égale à zéro n’est toutefois pas recommandée. Dans ce cas, il convient d’utiliser plutôt hideSection.

Voir également sectionResized(), sectionSize() et hideSection().

[protected slot] void QHeaderView::resizeSections()

Redimensionne les sections en fonction de leurs indications de taille. En règle générale, vous n'avez pas besoin 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'mode e indiquée, sans tenir compte du mode de redimensionnement actuel.

Voir également sectionResized().

bool QHeaderView::restoreState(const QByteArray &state)

Restaure l'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

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

Pour restaurer l'état enregistré, transmettez la valeur de retour à la fonction restoreState().

Voir également restoreState().

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

Ce signal est émis lorsqu'on clique sur une section. L'index logique de la section est spécifié par ` logicalIndex`.

Notez que le signal « sectionPressed » sera également émis.

Voir également 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'on double-clique sur une section. L'index logique de la section est spécifié par logicalIndex.

Voir également setSectionsClickable().

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

Ce signal est émis lorsque le curseur passe sur la section et que l'on appuie sur le bouton gauche de la souris. L'index logique de la section est spécifié par logicalIndex.

Voir également setSectionsClickable() et sectionPressed().

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

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

Voir également 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 le nouvel index par newVisualIndex.

Voir également moveSection().

int QHeaderView::sectionPosition(int logicalIndex) const

Renvoie la position de la section indiquée par ` logicalIndex`, ou -1 si la section est masquée. La position est mesurée en pixels, du coin supérieur gauche du premier élément visible au coin supérieur gauche de l'élément pour lequel ` logicalIndex` est défini. La mesure s'effectue le long de l'axe x pour les en-têtes horizontaux et le long de l'axe y pour les en-têtes verticaux.

Voir aussi sectionViewportPosition().

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

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

Voir également setSectionsClickable().

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

Renvoie le mode de redimensionnement applicable à la section spécifiée par l'logicalIndex donné.

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 également resizeSection().

int QHeaderView::sectionSize(int logicalIndex) const

Renvoie la largeur (ou la hauteur pour les en-têtes verticaux) de l'logicalIndex donné.

Voir également 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'logicalIndex donné.

Voir aussi defaultSectionSize().

int QHeaderView::sectionSizeHint(int logicalIndex) const

Renvoie une indication de taille adaptée à la section spécifiée par logicalIndex.

Qt::SizeHintRole

Voir également sizeHint(), defaultSectionSize(), minimumSectionSize() et maximumSectionSize().

int QHeaderView::sectionViewportPosition(int logicalIndex) const

Renvoie la position de la fenêtre de vue de section de l'logicalIndex donné.

Si la section est masquée, la valeur renvoyée n'est pas définie.

Voir également ` sectionPosition()` et ` isSectionHidden()`.

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

Cet emplacement est appelé lorsque des sections sont supprimées de l'parent. logicalFirst et logicalLast indiquent où les sections ont été supprimées.

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

bool QHeaderView::sectionsClickable() const

Renvoie les sections « Clickable ».

Voir aussi setSectionsClickable().

bool QHeaderView::sectionsHidden() const

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

Voir aussi setSectionHidden().

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

Cet emplacement est appelé lorsque des sections sont insérées dans le fichier parent. Les index logicalFirst et logicalLast indiquent l'emplacement où les nouvelles sections ont été insérées.

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

bool QHeaderView::sectionsMovable() const

Renvoie les sections de `sectionsMovable`.

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

Définit le décalage de l'en-tête sur offset.

Voir également offset() et length().

[slot] void QHeaderView::setOffsetToLastSection()

Définit le décalage permettant de rendre la dernière section visible.

Voir également 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 indiquée visualSectionNumber. visualSectionNumber correspond à la section réellement visible lorsque les sections masquées (hiddenSections) ne sont pas prises en compte. Cette valeur n'est pas toujours identique à celle renvoyée par la fonction visualIndex().

Voir également setOffset() et sectionPosition().

void QHeaderView::setResizeContentsPrecision(int precision)

Définit le niveau de précision avec lequel ` QHeaderView ` doit calculer la taille lorsque ` ResizeToContents ` est utilisé. Une valeur faible permettra un redimensionnement automatique moins précis mais plus rapide, tandis qu’une valeur plus élevée offrira un redimensionnement plus précis, mais qui peut s’avérer plus lent.

Le nombre precision spécifie le nombre de sections à prendre en compte lors du calcul de la taille recommandée.

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

La valeur spéciale 0 signifie qu’elle ne prendra en compte que la zone visible. La valeur spéciale -1 implique la prise en compte 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 rendre cette fonction inopérante.

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

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

Si hide est vrai, la section indiquée par logicalIndex est masquée ; dans le cas contraire, elle est affichée.

Voir également isSectionHidden() et hiddenSectionCount().

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

Définit les contraintes relatives au redimensionnement de l'en-tête conformément à celles décrites dans le document mode.

Voir également sectionResizeMode(), length() et sectionResized().

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

Définit les contraintes relatives au redimensionnement de la section spécifiée par ` logicalIndex ` dans l’en-tête, en fonction de celles décrites par la propriété ` mode` indiquée. L’index logique doit exister au moment de l’appel de cette fonction.

Voir également setStretchLastSection() et resizeContentsPrecision().

void QHeaderView::setSectionsClickable(bool clickable)

Définissez la propriété « sectionsClickable » sur « clickable ».

Voir également sectionsClickable().

void QHeaderView::setSectionsMovable(bool movable)

Définit la propriété « sectionsMovable » sur « movable ».

Voir également 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 dans l'rect donné en fonction de l'flags spécifié.

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 l'logicalIndex donné, dans la direction indiquée par order, et supprime l'indicateur de tri de toute autre section qui l'affichait.

logicalIndex La valeur peut être -1 ; dans ce cas, aucun indicateur de tri ne s'affichera et le modèle reviendra à son ordre naturel, non trié. Notez que tous les modèles ne prennent pas en charge cette fonctionnalité 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 pour la propriété : QWidget::visible.

void QHeaderView::showSection(int logicalIndex)

Affiche la section spécifiée par logicalIndex.

Voir également hideSection(), isSectionHidden(), hiddenSectionCount() et setSectionHidden().

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

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

Renvoie une estimation de taille appropriée pour cet en-tête.

Voir également 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ée. L'index logique de la section est spécifié par logicalIndex et l'ordre de tri est spécifié par order.

Voir également setSortIndicator().

Qt::SortOrder QHeaderView::sortIndicatorOrder() const

Renvoie l'ordre correspondant à l'indicateur de tri. Si aucune section ne dispose d'un indicateur de tri, la valeur renvoyée par cette fonction n'est pas définie.

Voir également setSortIndicator() et sortIndicatorSection().

int QHeaderView::sortIndicatorSection() const

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

Voir également setSortIndicator(), sortIndicatorOrder() et setSortIndicatorShown().

int QHeaderView::stretchSectionCount() const

Renvoie le nombre de sections configurées en mode de redimensionnement « stretch ». Dans les vues, cette fonction permet de vérifier 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)

Permute la section correspondant à l'index visuel first avec celle correspondant à l'index visuel second.

Voir également moveSection().

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

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

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

Voir également 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'index visuel de la section spécifiée par l'logicalIndex donné, ou -1 dans le cas contraire.

Les sections masquées possèdent toujours des indices visuels valides.

Voir aussi logicalIndex().

int QHeaderView::visualIndexAt(int position) const

Renvoie l'index visuel de la section qui recouvre l'position e spécifiée dans la fenêtre d'affichage.

Voir aussi logicalIndexAt().