QSizePolicy Class
La classe QSizePolicy est un attribut de mise en page décrivant la politique de redimensionnement horizontal et vertical. Plus d'informations...
| 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 |
Non-membres apparenté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 taille d'un widget exprime sa volonté d'être redimensionné de différentes manières et affecte la façon dont le widget est traité par le moteur de mise en page. Chaque widget renvoie une QSizePolicy qui décrit la politique de redimensionnement horizontal et vertical qu'il préfère lors de la mise en page. Vous pouvez modifier cette politique pour un widget spécifique en changeant sa propriété QWidget::sizePolicy.
QSizePolicy contient deux valeurs QSizePolicy::Policy indépendantes et deux facteurs d'étirement ; l'un décrit la politique de redimensionnement horizontal du widget, l'autre sa politique de redimensionnement vertical. Elle contient également un drapeau indiquant 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 et modifiées à l'aide des fonctions setHorizontalPolicy() et setVerticalPolicy(). Les facteurs d'étirement peuvent être définis à l'aide des fonctions setHorizontalStretch() et setVerticalStretch(). Le drapeau indiquant si la largeur du widget sizeHint() dépend de la largeur (comme une barre de menu ou une étiquette enveloppant un mot) 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(). Vous pouvez également utiliser la fonction transpose() pour intervertir les politiques et les étirements horizontaux et verticaux. La fonction hasHeightForWidth() renvoie l'état actuel du drapeau indiquant les dépendances de l'indice de taille.
Utilisez la fonction expandingDirections() pour déterminer si le widget associé peut utiliser plus d'espace que ne l'indique la fonction sizeHint(), ainsi que pour savoir dans quelles directions il peut s'étendre.
Enfin, la classe QSizePolicy fournit des opérateurs comparant cette politique de taille à une politique donnée, ainsi qu'un opérateur QVariant stockant cette QSizePolicy en tant qu'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 spécifie les différents types de widgets en termes d'interaction avec la mise en page :
| Constante | Constante Valeur | Description |
|---|---|---|
QSizePolicy::DefaultType | 0x00000001 | Le type par défaut, lorsqu'aucun n'est spécifié. |
QSizePolicy::ButtonBox | 0x00000002 | Une instance QDialogButtonBox. |
QSizePolicy::CheckBox | 0x00000004 | Une instance QCheckBox. |
QSizePolicy::ComboBox | 0x00000008 | Une instance QComboBox. |
QSizePolicy::Frame | 0x00000010 | Une instance QFrame. |
QSizePolicy::GroupBox | 0x00000020 | Une instance QGroupBox. |
QSizePolicy::Label | 0x00000040 | Une instance QLabel. |
QSizePolicy::Line | 0x00000080 | Une instance QFrame avec QFrame::HLine ou QFrame::VLine. |
QSizePolicy::LineEdit | 0x00000100 | Une instance QLineEdit. |
QSizePolicy::PushButton | 0x00000200 | Une instance QPushButton. |
QSizePolicy::RadioButton | 0x00000400 | Une instance QRadioButton. |
QSizePolicy::Slider | 0x00000800 | Une instance QAbstractSlider. |
QSizePolicy::SpinBox | 0x00001000 | Une instance QAbstractSpinBox. |
QSizePolicy::TabWidget | 0x00002000 | Une instance QTabWidget. |
QSizePolicy::ToolButton | 0x00004000 | Une instance QToolButton. |
Le type ControlTypes est un typedef pour QFlags<ControlType>. Il stocke une combinaison OR 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 construction d'un site QSizePolicy.
| Constante | Valeur | Description |
|---|---|---|
QSizePolicy::Fixed | 0 | QWidget::sizeHint() est la seule alternative acceptable, de sorte que le widget ne peut jamais grandir ou rétrécir (par exemple, la direction verticale d'un bouton-poussoir). |
QSizePolicy::Minimum | GrowFlag | L'indication 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 | Le paramètre sizeHint() est un maximum. Le widget peut être rétréci à 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 | Il est préférable d'utiliser la fonction sizeHint(), mais le widget peut être réduit et rester utile. Le widget peut être agrandi, mais il n'y a aucun avantage à ce qu'il soit plus grand que sizeHint() (politique par défaut de QWidget ). |
QSizePolicy::Expanding | GrowFlag | ShrinkFlag | ExpandFlag | La tailleHint() est raisonnable, mais le widget peut être réduit et rester utile. Le widget peut utiliser de l'espace supplémentaire, il doit donc disposer d'autant d'espace que possible (par exemple, la direction horizontale d'un curseur horizontal). |
QSizePolicy::MinimumExpanding | GrowFlag | ExpandFlag | La fonction sizeHint() est minimale et suffisante. Le widget peut utiliser de l'espace supplémentaire, il doit donc obtenir autant d'espace que possible (par exemple, la direction horizontale 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 aussi PolicyFlag, setHorizontalPolicy(), et setVerticalPolicy().
enum QSizePolicy::PolicyFlag
Ces drapeaux sont combinés pour former les différentes valeurs de Policy:
| Constante | Valeur | Description |
|---|---|---|
QSizePolicy::GrowFlag | 1 | Le widget peut dépasser son indice de taille si nécessaire. |
QSizePolicy::ExpandFlag | 2 | Le widget doit disposer d'autant d'espace que possible. |
QSizePolicy::ShrinkFlag | 4 | Le widget peut se rétrécir en dessous de son indice de taille si nécessaire. |
QSizePolicy::IgnoreFlag | 8 | L'indice de taille du widget est ignoré. Le widget obtiendra autant d'espace que possible. |
Voir aussi Policy.
Documentation des fonctions membres
[constexpr noexcept] QSizePolicy::QSizePolicy()
Construit un objet QSizePolicy avec Fixed comme politique horizontale et verticale.
Les politiques peuvent être modifiées à l'aide des fonctions setHorizontalPolicy() et setVerticalPolicy(). Utilisez la fonction 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() et setVerticalStretch().
[constexpr noexcept] QSizePolicy::QSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical, QSizePolicy::ControlType type = DefaultType)
Construit un objet QSizePolicy avec les politiques horizontal et vertical données, et le contrôle spécifié type.
Utilisez 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 pour lequel cette politique de taille s'applique.
Voir aussi setControlType().
[constexpr noexcept] Qt::Orientations QSizePolicy::expandingDirections() const
Renvoie si un widget peut utiliser plus d'espace que ne l'indique la fonction QWidget::sizeHint().
Une valeur de Qt::Horizontal ou Qt::Vertical signifie que le widget peut s'agrandir 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'agrandir 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 aussi 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 aussi setHorizontalPolicy(), verticalPolicy() et horizontalStretch().
[constexpr noexcept] int QSizePolicy::horizontalStretch() const
Renvoie le facteur d'étirement horizontal de la politique de taille.
Voir aussi 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 caché. 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 pour lequel cette politique de taille s'applique à type.
Le type de contrôle spécifie le type de widget pour lequel cette politique de taille s'applique. Il est utilisé par certains styles, notamment QMacStyle, pour insérer un espacement approprié entre les widgets. Par exemple, les directives macOS Aqua précisent que les boutons poussoirs doivent être séparés de 12 pixels, alors que les boutons radio empilés verticalement n'ont besoin que de 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, à dependent.
Voir également hasHeightForWidth() et setWidthForHeight().
[constexpr noexcept] void QSizePolicy::setHorizontalPolicy(QSizePolicy::Policy policy)
Fixe la composante horizontale à la valeur donnée policy.
Voir aussi horizontalPolicy(), setVerticalPolicy() et setHorizontalStretch().
[constexpr] void QSizePolicy::setHorizontalStretch(int stretchFactor)
Définit le facteur d'étirement horizontal de la politique de taille à stretchFactor. stretchFactor doit être compris 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 à 2 et le facteur du widget de droite à 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éfinit si une disposition doit conserver la taille du widget lorsqu'il est caché. Si retainSize est true, la disposition ne sera pas modifiée par le masquage du widget.
Voir aussi retainSizeWhenHidden().
[constexpr noexcept] void QSizePolicy::setVerticalPolicy(QSizePolicy::Policy policy)
Fixe la composante verticale à la valeur donnée policy.
Voir aussi verticalPolicy(), setHorizontalPolicy() et setVerticalStretch().
[constexpr] void QSizePolicy::setVerticalStretch(int stretchFactor)
Définit le facteur d'étirement vertical de la politique de taille à stretchFactor. stretchFactor doit être compris dans l'intervalle [0,255].
Lorsque deux widgets sont adjacents dans une disposition verticale, le fait de fixer le facteur d'étirement vertical du widget du haut à 2 et le facteur du widget du bas à 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, à dependent.
Cette fonction n'est prise en charge que pour les sous-classes de QGraphicsLayout. Il n'est pas possible d'avoir une disposition avec des contraintes de hauteur pour la largeur et de largeur pour la hauteur en même temps.
Voir également hasWidthForHeight() et setHeightForWidth().
[constexpr noexcept] void QSizePolicy::transpose()
Intervertit les politiques horizontales et verticales et les étirements.
Voir également transposed().
[constexpr noexcept] QSizePolicy QSizePolicy::transposed() const
Renvoie un objet de politique de taille avec les politiques horizontales et verticales et les étirements échangés.
Voir également transpose().
[constexpr noexcept] QSizePolicy::Policy QSizePolicy::verticalPolicy() const
Renvoie la composante verticale de la politique de taille.
Voir aussi setVerticalPolicy(), horizontalPolicy() et verticalStretch().
[constexpr noexcept] int QSizePolicy::verticalStretch() const
Renvoie le facteur d'étirement vertical de la politique de taille.
Voir aussi setVerticalStretch(), horizontalStretch() et verticalPolicy().
QSizePolicy::operator QVariant() const
Renvoie un QVariant contenant ce QSizePolicy.
[constexpr noexcept] bool QSizePolicy::operator!=(const QSizePolicy &other) const
Renvoie true si cette politique est différente de other; sinon, renvoie false.
Voir aussi operator==().
[constexpr noexcept] bool QSizePolicy::operator==(const QSizePolicy &other) const
Renvoie true si cette politique est égale à other; sinon, renvoie false.
Voir aussi operator!=().
Non-membres apparentés
[noexcept] size_t qHash(QSizePolicy key, size_t seed = 0)
Renvoie la valeur de hachage pour key, en utilisant seed comme base de calcul.
QDataStream &operator<<(QDataStream &stream, const QSizePolicy &policy)
Écrit la taille policy dans le flux de données stream.
Voir aussi Format des opérateurs QDataStream.
QDataStream &operator>>(QDataStream &stream, QSizePolicy &policy)
Lit la taille policy dans le flux de données stream.
Voir aussi 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.
