QGraphicsLinearLayout Class
La classe `QGraphicsLinearLayout` permet de définir une disposition horizontale ou verticale pour la gestion des widgets dans la vue graphique. En savoir plus...
| En-tête : | #include <QGraphicsLinearLayout> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake : | QT += widgets |
| Hérite de : | QGraphicsLayout |
Fonctions publiques
| QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr) | |
| QGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent = nullptr) | |
| virtual | ~QGraphicsLinearLayout() |
| void | addItem(QGraphicsLayoutItem *item) |
| void | addStretch(int stretch = 1) |
| Qt::Alignment | alignment(QGraphicsLayoutItem *item) const |
| void | insertItem(int index, QGraphicsLayoutItem *item) |
| void | insertStretch(int index, int stretch = 1) |
| qreal | itemSpacing(int index) const |
| Qt::Orientation | orientation() const |
| void | removeItem(QGraphicsLayoutItem *item) |
| void | setAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment) |
| void | setItemSpacing(int index, qreal spacing) |
| void | setOrientation(Qt::Orientation orientation) |
| void | setSpacing(qreal spacing) |
| void | setStretchFactor(QGraphicsLayoutItem *item, int stretch) |
| qreal | spacing() const |
| int | stretchFactor(QGraphicsLayoutItem *item) const |
Fonctions publiques réimplémentées
| virtual int | count() const override |
| virtual void | invalidate() override |
| virtual QGraphicsLayoutItem * | itemAt(int index) const override |
| virtual void | removeAt(int index) override |
| virtual void | setGeometry(const QRectF &rect) override |
| virtual QSizeF | sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const override |
Description détaillée
L'orientation par défaut d'une disposition linéaire est Qt::Horizontal. Vous pouvez choisir une orientation verticale soit en appelant setOrientation(), soit en passant Qt::Vertical au constructeur de QGraphicsLinearLayout.
La manière la plus courante d'utiliser QGraphicsLinearLayout consiste à créer un objet sur le tas, en passant un widget parent au constructeur, puis à ajouter des widgets et des dispositions en appelant addItem().
QGraphicsScene scene;
QGraphicsWidget *textEdit = scene.addWidget(new QTextEdit);
QGraphicsWidget *pushButton = scene.addWidget(new QPushButton);
QGraphicsWidget *form = new QGraphicsWidget;
scene.addItem(form);
QGraphicsLinearLayout *layout = new QGraphicsLinearLayout(form);
layout->addItem(textEdit);
layout->addItem(pushButton);Sinon, si vous ne passez pas de widget parent au constructeur de la mise en page, vous devrez appeler QGraphicsWidget::setLayout() pour définir cette mise en page comme mise en page de niveau supérieur pour ce widget ; le widget prendra alors possession de la mise en page.
Vous pouvez ajouter des widgets, des mises en page, des étirements (addStretch(), insertStretch() ou setStretchFactor()) et des espacements (setItemSpacing()) à une mise en page linéaire. La mise en page prend en charge les éléments. Dans certains cas, lorsque l’élément de mise en page hérite également de « QGraphicsItem » (comme QGraphicsWidget), il y a une ambiguïté de propriété car l’élément de mise en page appartient à deux hiérarchies de propriété. Consultez la documentation de QGraphicsLayoutItem::setOwnedByLayout() pour savoir comment gérer cette situation. Vous pouvez accéder à chaque élément de la mise en page en appelant count() et itemAt(). L'appel de removeAt() ou removeItem() supprime un élément de la mise en page, sans le détruire.
Indications de taille et politiques de taille dans QGraphicsLinearLayout
QGraphicsLinearLayout respecte les indications de taille et les politiques de taille de chaque élément. Lorsque la mise en page dispose de plus d’espace que les éléments ne peuvent en occuper, chaque élément est positionné selon l’alignement défini par la mise en page pour cet élément. Vous pouvez définir un alignement pour chaque élément en appelant ` setAlignment()` et vérifier l’alignement de n’importe quel élément en appelant ` alignment()`. Par défaut, les éléments sont alignés en haut à gauche.
Espacement au sein de QGraphicsLinearLayout
La mise en page répartit un certain espace entre les éléments. La quantité réelle d’espace dépend du style actuel du widget géré, mais l’espacement par défaut est de 4. Vous pouvez également définir votre propre espacement en appelant la fonction ` setSpacing()` et obtenir la valeur d’espacement actuelle en appelant la fonction ` spacing()`. Si vous souhaitez configurer un espacement individuel pour vos éléments, vous pouvez appeler la fonction ` setItemSpacing()`.
Facteur d'étirement dans QGraphicsLinearLayout
Vous pouvez attribuer un facteur d’étirement à chaque élément afin de contrôler l’espace qui lui sera alloué par rapport aux autres éléments. Par défaut, deux widgets identiques disposés dans une mise en page linéaire auront la même taille, mais si le premier widget a un facteur d'étirement de 1 et le second un facteur d'étirement de 2, le premier widget occupera 1/3 de l'espace disponible, et le second 2/3.
QGraphicsLinearLayout calcule la répartition des tailles en additionnant les facteurs d’étirement de tous les éléments, puis en divisant l’espace disponible en conséquence. Le facteur d’étirement par défaut est 0 pour tous les éléments ; un facteur de 0 signifie que l’élément n’a pas de facteur d’étirement défini ; cela revient en fait à définir le facteur d’étirement à 1. Le facteur d'étirement s'applique uniquement à l'espace disponible dans le sens de la longueur de la disposition (selon son orientation). Si vous souhaitez contrôler à la fois l'étirement horizontal et vertical de l'élément, vous pouvez utiliser à la place QGraphicsGridLayout.
Comparaison entre QGraphicsLinearLayout et d’autres dispositions
QGraphicsLinearLayout est très similaire à QVBoxLayout et QHBoxLayout, mais contrairement à ces classes, il est utilisé pour gérer QGraphicsWidget et QGraphicsLayout au lieu de QWidget et QLayout.
Voir également QGraphicsGridLayout et QGraphicsWidget.
Documentation sur les fonctions membres
QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)
Crée une instance de `QGraphicsLinearLayout` en utilisant l'orientation ` Qt::Horizontal `. ` parent ` est transmis au constructeur de ` QGraphicsLayout`.
QGraphicsLinearLayout::QGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent = nullptr)
Crée une instance de `QGraphicsLinearLayout`. Vous pouvez lui transmettre l'orientation, qui peut être horizontale ou verticale, et ` parent ` est transmis au constructeur de ` QGraphicsLayout`.
[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()
Supprime l'objet « QGraphicsLinearLayout ».
void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)
Cette fonction pratique revient à appeler ` insertItem(-1, item)`.
void QGraphicsLinearLayout::addStretch(int stretch = 1)
Cette fonction pratique revient à appeler ` insertStretch(-1, stretch)`.
Qt::Alignment QGraphicsLinearLayout::alignment(QGraphicsLayoutItem *item) const
Renvoie l'alignement d'item. L'alignement par défaut est Qt::AlignTop | Qt::AlignLeft.
L'alignement détermine la manière dont l'élément est positionné dans l'espace qui lui est attribué lorsque l'espace disponible dans la mise en page est supérieur à celui que les widgets peuvent occuper.
Voir également setAlignment().
[override virtual] int QGraphicsLinearLayout::count() const
Réimplémente : QGraphicsLayout::count() const.
void QGraphicsLinearLayout::insertItem(int index, QGraphicsLayoutItem *item)
Insère item dans la mise en page à l'adresse index, ou avant tout élément se trouvant actuellement à l'adresse index.
Voir également addItem(), itemAt(), insertStretch() et setItemSpacing().
void QGraphicsLinearLayout::insertStretch(int index, int stretch = 1)
Insère un extrait de stretch à l'adresse index, ou avant n'importe quel élément se trouvant actuellement à l'adresse index.
Voir également addStretch(), setStretchFactor(), setItemSpacing() et insertItem().
[override virtual] void QGraphicsLinearLayout::invalidate()
Réimplémente : QGraphicsLayout::invalidate().
[override virtual] QGraphicsLayoutItem *QGraphicsLinearLayout::itemAt(int index) const
Réimplémentation de : ` QGraphicsLayout::itemAt(int i) const`.
Lors d'une itération commençant à 0, elle renvoie les éléments dans l'ordre dans lequel ils sont affichés.
qreal QGraphicsLinearLayout::itemSpacing(int index) const
Renvoie l'espacement après un élément à l'adresse index.
Voir également setItemSpacing().
Qt::Orientation QGraphicsLinearLayout::orientation() const
Renvoie l'orientation de la mise en page.
Voir aussi setOrientation().
[override virtual] void QGraphicsLinearLayout::removeAt(int index)
Réimplémente : QGraphicsLayout::removeAt(int index).
Supprime l'élément situé à l'adresse index sans le détruire. La propriété de l'élément est transférée à l'appelant.
Voir également removeItem() et insertItem().
void QGraphicsLinearLayout::removeItem(QGraphicsLayoutItem *item)
Supprime item de la mise en page sans la détruire. La propriété de item est transférée à l'appelant.
Voir également removeAt() et insertItem().
void QGraphicsLinearLayout::setAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
Définit l'alignement de item sur alignment. Si l'alignement de item change, la mise en page est automatiquement invalidée.
Voir également alignment() et invalidate().
[override virtual] void QGraphicsLinearLayout::setGeometry(const QRectF &rect)
Réimplémentation de : QGraphicsLayoutItem::setGeometry(const QRectF &rect).
void QGraphicsLinearLayout::setItemSpacing(int index, qreal spacing)
Définit l'espacement après l'élément à index sur spacing.
Voir également itemSpacing().
void QGraphicsLinearLayout::setOrientation(Qt::Orientation orientation)
Modifiez l'orientation de la mise en page en orientation. La modification de l'orientation de la mise en page entraînera automatiquement l'invalidation de celle-ci.
Voir également orientation().
void QGraphicsLinearLayout::setSpacing(qreal spacing)
Définit l'espacement de la mise en page sur spacing. L'espacement fait référence aux distances verticales et horizontales entre les éléments.
Voir également spacing(), setItemSpacing(), setStretchFactor() et QGraphicsGridLayout::setSpacing().
void QGraphicsLinearLayout::setStretchFactor(QGraphicsLayoutItem *item, int stretch)
Définit le facteur d'étirement de item à stretch. Si le facteur d'étirement d'un élément change, cette fonction invalide la mise en page.
Définir ` stretch ` sur 0 supprime le facteur d'étirement de l'élément, ce qui revient en pratique à définir ` stretch ` sur 1.
Voir également stretchFactor().
[override virtual] QSizeF QGraphicsLinearLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
Réimplémente : QGraphicsLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const.
qreal QGraphicsLinearLayout::spacing() const
Renvoie l'espacement de la mise en page. L'espacement désigne les distances verticales et horizontales entre les éléments.
Voir également setSpacing().
int QGraphicsLinearLayout::stretchFactor(QGraphicsLayoutItem *item) const
Renvoie le facteur d'étirement pour item. Le facteur d'étirement par défaut est 0, ce qui signifie qu'aucun facteur d'étirement n'est attribué à l'élément.
Voir également setStretchFactor().
© 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.
