QSizePolicy Class
La classe QSizePolicy est un attribut de mise en page qui définit les règles de redimensionnement horizontal et vertical. En savoir plus...
| En-tête : | #include <QSizePolicy> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake : | QT += widgets |
Types publics
| enum | ControlType { DefaultType, ButtonBox, CheckBox, ComboBox, Frame, …, ToolButton } |
| flags | ControlTypes |
| enum | Policy { Fixed, Minimum, Maximum, Preferred, Expanding, …, Ignored } |
| enum | PolicyFlag { GrowFlag, ExpandFlag, ShrinkFlag, IgnoreFlag } |
Fonctions publiques
| QSizePolicy() | |
| QSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical, QSizePolicy::ControlType type = DefaultType) | |
| QSizePolicy::ControlType | controlType() const |
| Qt::Orientations | expandingDirections() const |
| bool | hasHeightForWidth() const |
| bool | hasWidthForHeight() const |
| QSizePolicy::Policy | horizontalPolicy() const |
| int | horizontalStretch() const |
| bool | retainSizeWhenHidden() const |
| void | setControlType(QSizePolicy::ControlType type) |
| void | setHeightForWidth(bool dependent) |
| void | setHorizontalPolicy(QSizePolicy::Policy policy) |
| void | setHorizontalStretch(int stretchFactor) |
| void | setRetainSizeWhenHidden(bool retainSize) |
| void | setVerticalPolicy(QSizePolicy::Policy policy) |
| void | setVerticalStretch(int stretchFactor) |
| void | setWidthForHeight(bool dependent) |
| void | transpose() |
| QSizePolicy | transposed() const |
| QSizePolicy::Policy | verticalPolicy() const |
| int | verticalStretch() const |
| operator QVariant() const | |
| bool | operator!=(const QSizePolicy &other) const |
| bool | operator==(const QSizePolicy &other) const |
Éléments non membres associés
| size_t | qHash(QSizePolicy key, size_t seed = 0) |
| QDataStream & | operator<<(QDataStream &stream, const QSizePolicy &policy) |
| QDataStream & | operator>>(QDataStream &stream, QSizePolicy &policy) |
Description détaillée
La politique de redimensionnement d’un widget exprime sa capacité à être redimensionné de différentes manières et influe sur la façon dont le moteur de mise en page traite ce widget. Chaque widget renvoie un objet QSizePolicy qui décrit la politique de redimensionnement horizontal et vertical qu’il privilégie lors de sa mise en page. Vous pouvez modifier ce comportement pour un widget spécifique en modifiant sa propriété QWidget::sizePolicy.
QSizePolicy contient deux valeurs d’ QSizePolicy::Policy indépendantes et deux facteurs d’étirement ; l’une décrit la politique de redimensionnement horizontal du widget, et l’autre sa politique de redimensionnement vertical. Elle contient également un indicateur précisant si la hauteur et la largeur de sa taille préférée sont liées.
Les politiques horizontale et verticale peuvent être définies dans le constructeur, puis modifiées à l’aide des fonctions ` setHorizontalPolicy()` et ` setVerticalPolicy()`. Les facteurs d’étirement peuvent être définis à l’aide des fonctions ` setHorizontalStretch()` et ` setVerticalStretch()`. L’indicateur précisant si la propriété ` sizeHint()` du widget dépend de la largeur (comme une barre de menu ou une étiquette à retour à la ligne automatique) peut être défini à l’aide de la fonction ` setHeightForWidth()`.
Les politiques de taille et les facteurs d’étirement actuels peuvent être récupérés à l’aide des fonctions horizontalPolicy(), verticalPolicy(), horizontalStretch() et verticalStretch(). Il est également possible d’utiliser la fonction transpose() pour permuter les politiques et les étirements horizontaux et verticaux. La fonction hasHeightForWidth() renvoie l’état actuel de l’indicateur signalant les dépendances des indications de taille.
Utilisez la fonction ` expandingDirections()` pour déterminer si le widget associé peut utiliser plus d’espace que ce qu’indique sa fonction ` sizeHint()`, ainsi que pour savoir dans quelles directions il peut s’étendre.
Enfin, la classe `QSizePolicy` fournit des opérateurs permettant de comparer cette politique de taille à une politique donnée, ainsi qu’un opérateur ` QVariant ` permettant de stocker cette `QSizePolicy` sous la forme d’un objet ` QVariant `.
Voir également QSize, QWidget::sizeHint(), QWidget::sizePolicy et QLayoutItem::sizeHint().
Documentation sur les types de membres
enum QSizePolicy::ControlType
flags QSizePolicy::ControlTypes
Cette énumération définit les différents types de widgets en fonction de leur interaction avec la mise en page :
| Constante | Valeur | Description |
|---|---|---|
QSizePolicy::DefaultType | 0x00000001 | Type par défaut, lorsqu'aucun n'est spécifié. |
QSizePolicy::ButtonBox | 0x00000002 | Une instance de ` QDialogButtonBox `. |
QSizePolicy::CheckBox | 0x00000004 | Une instance de ` QCheckBox `. |
QSizePolicy::ComboBox | 0x00000008 | Une instance de ` QComboBox `. |
QSizePolicy::Frame | 0x00000010 | Une instance de ` QFrame `. |
QSizePolicy::GroupBox | 0x00000020 | Une instance de ` QGroupBox `. |
QSizePolicy::Label | 0x00000040 | Une instance d'QLabel. |
QSizePolicy::Line | 0x00000080 | Une instance d'QFrame avec QFrame::HLine ou QFrame::VLine. |
QSizePolicy::LineEdit | 0x00000100 | Une instance de QLineEdit. |
QSizePolicy::PushButton | 0x00000200 | Une instance d'QPushButton. |
QSizePolicy::RadioButton | 0x00000400 | Une instance de QRadioButton. |
QSizePolicy::Slider | 0x00000800 | Une instance « QAbstractSlider ». |
QSizePolicy::SpinBox | 0x00001000 | Une instance d'QAbstractSpinBox. |
QSizePolicy::TabWidget | 0x00002000 | Une instance d'QTabWidget. |
QSizePolicy::ToolButton | 0x00004000 | Une instance de ` QToolButton `. |
Le type ControlTypes est une définition de type (typedef) pour QFlags<ControlType>. Il stocke une combinaison « OU » de valeurs ControlType.
Voir également setControlType() et controlType().
enum QSizePolicy::Policy
Cette énumération décrit les différents types de dimensionnement par dimension utilisés lors de la création d'un objet ` QSizePolicy`.
| Constante | Valeur | Description |
|---|---|---|
QSizePolicy::Fixed | 0 | Le widget « QWidget::sizeHint() » est la seule alternative acceptable ; le widget ne peut donc jamais s’agrandir ni se réduire (par exemple, la direction verticale d’un bouton-poussoir). |
QSizePolicy::Minimum | GrowFlag | La valeur de sizeHint() est minimale et suffisante. Le widget peut être agrandi, mais il n’y a aucun avantage à ce qu’il soit plus grand (par exemple, la direction horizontale d’un bouton-poussoir). Il ne peut pas être plus petit que la taille fournie par sizeHint(). |
QSizePolicy::Maximum | ShrinkFlag | La valeur de `sizeHint()` correspond à une taille maximale. Le widget peut être réduit à volonté sans inconvénient si d’autres widgets ont besoin d’espace (par exemple, une ligne de séparation). Il ne peut pas être plus grand que la taille fournie par `sizeHint()`. |
QSizePolicy::Preferred | GrowFlag | ShrinkFlag | La valeur fournie par sizeHint() est optimale, mais le widget peut être réduit tout en restant utile. Le widget peut être agrandi, mais il n’y a aucun avantage à ce qu’il soit plus grand que la valeur fournie par sizeHint() (politique par défaut d’ QWidget ). |
QSizePolicy::Expanding | GrowFlag | ShrinkFlag | ExpandFlag | La valeur fournie par sizeHint() est raisonnable, mais le widget peut être réduit tout en restant utile. Le widget peut tirer parti de l’espace supplémentaire ; il doit donc disposer d’autant d’espace que possible (par exemple, dans le sens horizontal d’un curseur horizontal). |
QSizePolicy::MinimumExpanding | GrowFlag | ExpandFlag | La valeur sizeHint() est minimale et suffisante. Le widget peut exploiter l’espace supplémentaire ; il doit donc se voir attribuer autant d’espace que possible (par exemple, dans le sens horizontal d’un curseur horizontal). |
QSizePolicy::Ignored | ShrinkFlag | GrowFlag | IgnoreFlag | La fonction sizeHint() est ignorée. Le widget disposera d’autant d’espace que possible. |
Voir également PolicyFlag, setHorizontalPolicy() et setVerticalPolicy().
enum QSizePolicy::PolicyFlag
Ces indicateurs sont combinés entre eux pour former les différentes valeurs de l'Policy:
| Constante | Valeur | Description |
|---|---|---|
QSizePolicy::GrowFlag | 1 | Le widget peut dépasser la taille indiquée si nécessaire. |
QSizePolicy::ExpandFlag | 2 | Le widget doit disposer d'autant d'espace que possible. |
QSizePolicy::ShrinkFlag | 4 | Le widget peut se réduire en dessous de sa taille indiquée si nécessaire. |
QSizePolicy::IgnoreFlag | 8 | La taille indiquée pour le widget est ignorée. Le widget occupera autant d’espace que possible. |
Voir aussi Policy.
Documentation des fonctions membres
[constexpr noexcept] QSizePolicy::QSizePolicy()
Crée un objet `QSizePolicy` dont les politiques horizontale et verticale sont respectivement ` Fixed `.
Ces politiques peuvent être modifiées à l'aide des fonctions ` setHorizontalPolicy()` et ` setVerticalPolicy()`. Utilisez la fonction ` setHeightForWidth()` si la hauteur souhaitée du widget dépend de sa largeur (par exemple, une boîte de texte ` QLabel ` avec retour à la ligne automatique).
Voir également setHorizontalStretch() et setVerticalStretch().
[constexpr noexcept] QSizePolicy::QSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical, QSizePolicy::ControlType type = DefaultType)
Crée un objet `QSizePolicy` avec les politiques ` horizontal ` et ` vertical ` fournies, ainsi que le contrôle spécifié ` type`.
Utilisez la méthode ` setHeightForWidth()` si la hauteur préférée du widget dépend de sa largeur (par exemple, un ` QLabel ` avec retour à la ligne).
Voir également setHorizontalStretch(), setVerticalStretch() et controlType().
[noexcept] QSizePolicy::ControlType QSizePolicy::controlType() const
Renvoie le type de contrôle associé au widget auquel s'applique cette politique de taille.
Voir aussi setControlType().
[constexpr noexcept] Qt::Orientations QSizePolicy::expandingDirections() const
Indique si un widget peut occuper plus d'espace que ce qu'indique la fonction ` QWidget::sizeHint()`.
Une valeur de type Qt::Horizontal ou Qt::Vertical signifie que le widget peut s'étendre horizontalement ou verticalement (c'est-à-dire que la politique horizontale ou verticale est Expanding ou MinimumExpanding), tandis que Qt::Horizontal | Qt::Vertical signifie qu'il peut s'étendre dans les deux dimensions.
Voir également horizontalPolicy() et verticalPolicy().
[constexpr noexcept] bool QSizePolicy::hasHeightForWidth() const
Renvoie « true » si la hauteur préférée du widget dépend de sa largeur ; sinon, renvoie « false ».
Voir également setHeightForWidth().
[constexpr noexcept] bool QSizePolicy::hasWidthForHeight() const
Renvoie « true » si la largeur du widget dépend de sa hauteur ; sinon, renvoie « false ».
Voir aussi setWidthForHeight().
[constexpr noexcept] QSizePolicy::Policy QSizePolicy::horizontalPolicy() const
Renvoie la composante horizontale de la politique de taille.
Voir également setHorizontalPolicy(), verticalPolicy() et horizontalStretch().
[constexpr noexcept] int QSizePolicy::horizontalStretch() const
Renvoie le facteur d'étirement horizontal de la politique de dimensionnement.
Voir également setHorizontalStretch(), verticalStretch() et horizontalPolicy().
[constexpr noexcept] bool QSizePolicy::retainSizeWhenHidden() const
Indique si la mise en page doit conserver la taille du widget lorsqu'il est masqué. La valeur par défaut est « false ».
Voir également ` setRetainSizeWhenHidden()`.
[noexcept] void QSizePolicy::setControlType(QSizePolicy::ControlType type)
Définit le type de contrôle associé au widget auquel s'applique cette politique de taille : type.
Le type de contrôle spécifie le type du widget auquel s'applique cette politique de taille. Il est utilisé par certains styles, notamment QMacStyle, pour insérer un espacement approprié entre les widgets. Par exemple, les directives Aqua de macOS spécifient que les boutons poussoirs doivent être séparés de 12 pixels, tandis que les boutons radio empilés verticalement ne nécessitent que 6 pixels.
Voir également controlType() et QStyle::layoutSpacing().
[constexpr noexcept] void QSizePolicy::setHeightForWidth(bool dependent)
Définit l'indicateur déterminant si la hauteur préférée du widget dépend de sa largeur, sur la valeur « dependent ».
Voir également ` hasHeightForWidth()` et ` setWidthForHeight()`.
[constexpr noexcept] void QSizePolicy::setHorizontalPolicy(QSizePolicy::Policy policy)
Définit la composante horizontale sur la valeur indiquée policy.
Voir également horizontalPolicy(), setVerticalPolicy() et setHorizontalStretch().
[constexpr] void QSizePolicy::setHorizontalStretch(int stretchFactor)
Définit le facteur d'étirement horizontal de la politique de taille sur la valeur indiquée stretchFactor. La valeur « stretchFactor » doit être comprise dans l'intervalle [0,255].
Lorsque deux widgets sont adjacents dans une disposition horizontale, le fait de définir le facteur d’étirement horizontal du widget de gauche sur 2 et celui du widget de droite sur 1 garantit que le widget de gauche aura toujours une taille deux fois supérieure à celle du widget de droite.
Voir également horizontalStretch(), setVerticalStretch() et setHorizontalPolicy().
[constexpr noexcept] void QSizePolicy::setRetainSizeWhenHidden(bool retainSize)
Détermine si une disposition doit conserver la taille du widget lorsqu'il est masqué. Si la propriété ` retainSize ` prend la valeur ` true`, la disposition ne sera pas modifiée par le masquage du widget.
Voir également retainSizeWhenHidden().
[constexpr noexcept] void QSizePolicy::setVerticalPolicy(QSizePolicy::Policy policy)
Définit la composante verticale sur la valeur indiquée policy.
Voir également verticalPolicy(), setHorizontalPolicy() et setVerticalStretch().
[constexpr] void QSizePolicy::setVerticalStretch(int stretchFactor)
Définit le facteur d'étirement vertical de la politique de taille sur la valeur indiquée stretchFactor. La valeur stretchFactor doit être comprise entre 0 et 255.
Lorsque deux widgets sont adjacents dans une disposition verticale, le fait de définir le facteur d’étirement vertical du widget du haut sur 2 et celui du widget du bas sur 1 garantit que le widget du haut aura toujours une taille deux fois supérieure à celle du widget du bas.
Voir également verticalStretch(), setHorizontalStretch() et setVerticalPolicy().
[constexpr noexcept] void QSizePolicy::setWidthForHeight(bool dependent)
Définit l'indicateur déterminant si la largeur du widget dépend de sa hauteur, sur la valeur « dependent ».
Cette fonctionnalité n'est prise en charge que pour les sous-classes de ` QGraphicsLayout`. Il n'est pas possible d'avoir une mise en page comportant à la fois des contraintes de type « hauteur pour la largeur » et « largeur pour la hauteur ».
Voir également ` hasWidthForHeight()` et ` setHeightForWidth()`.
[constexpr noexcept] void QSizePolicy::transpose()
Permet d'inverser les alignements horizontal et vertical et d'étirer le texte.
Voir également transposed().
[constexpr noexcept] QSizePolicy QSizePolicy::transposed() const
Renvoie un objet de politique de redimensionnement dans lequel les politiques horizontale et verticale ainsi que les étirements sont inversés.
Voir également transpose().
[constexpr noexcept] QSizePolicy::Policy QSizePolicy::verticalPolicy() const
Renvoie la composante verticale de la politique de dimensionnement.
Voir également setVerticalPolicy(), horizontalPolicy() et verticalStretch().
[constexpr noexcept] int QSizePolicy::verticalStretch() const
Renvoie le facteur d'étirement vertical de la politique de dimensionnement.
Voir également setVerticalStretch(), horizontalStretch() et verticalPolicy().
QSizePolicy::operator QVariant() const
Renvoie un objet ` QVariant ` contenant cette ` QSizePolicy`.
[constexpr noexcept] bool QSizePolicy::operator!=(const QSizePolicy &other) const
Renvoie true si cette politique diffère de other; sinon, renvoie false.
Voir également operator==().
[constexpr noexcept] bool QSizePolicy::operator==(const QSizePolicy &other) const
Renvoie true si cette politique est égale à other; sinon, renvoie false.
Voir aussi operator!=().
Éléments non membres associés
[noexcept] size_t qHash(QSizePolicy key, size_t seed = 0)
Renvoie la valeur de hachage de key, en utilisant seed comme graine pour le calcul.
QDataStream &operator<<(QDataStream &stream, const QSizePolicy &policy)
Écrit l'policy de taille dans le flux de données stream.
Voir également Format des opérateurs QDataStream.
QDataStream &operator>>(QDataStream &stream, QSizePolicy &policy)
Lit l'policy de taille à partir du flux de données stream.
Voir également Format des opérateurs QDataStream.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.
