QGraphicsLinearLayout Class
La classe QGraphicsLinearLayout fournit une disposition horizontale ou verticale pour la gestion des widgets dans la vue graphique. Plus d'informations...
| En-tête : | #include <QGraphicsLinearLayout> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Widgets)target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake : | QT += widgets |
| Héritages : | 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 présentation 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 est de construire un objet sur le tas, en passant un widget parent au constructeur, puis d'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);
Si vous ne passez pas de widget parent au constructeur de la disposition, vous devrez appeler QGraphicsWidget::setLayout() pour définir cette disposition comme la disposition de premier niveau pour ce widget, qui deviendra propriétaire de la disposition.
Vous pouvez ajouter des widgets, des dispositions, des étirements (addStretch(), insertStretch() ou setStretchFactor()) et des espacements (setItemSpacing()) à une disposition linéaire. La mise en page est propriétaire des éléments. Dans certains cas, lorsque l'élément de disposition hérite également de QGraphicsItem (comme QGraphicsWidget), il y a une ambiguïté dans la propriété car l'élément de disposition appartient à deux hiérarchies de propriété. Voir la documentation de QGraphicsLayoutItem::setOwnedByLayout() pour savoir comment gérer ce problème. Vous pouvez accéder à chaque élément de la présentation en appelant count() et itemAt(). L'appel à removeAt() ou removeItem() supprimera un élément de la présentation, sans le détruire.
Indices et politiques de taille dans QGraphicsLinearLayout
QGraphicsLinearLayout respecte les indications et les règles de taille de chaque élément et, lorsque la disposition contient plus d'espace que les éléments ne peuvent en occuper, chaque élément est disposé conformément à l'alignement de la disposition 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 dans QGraphicsLinearLayout
Entre les éléments, la mise en page distribue de l'espace. La quantité réelle d'espace dépend du style actuel du widget géré, mais l'espacement courant est de 4. Vous pouvez également définir votre propre espacement en appelant setSpacing(), et obtenir la valeur de l'espacement actuel en appelant spacing(). Si vous souhaitez configurer l'espacement individuel de vos éléments, vous pouvez appeler setItemSpacing().
Facteur d'étirement dans QGraphicsLinearLayout
Vous pouvez attribuer un facteur d'étirement à chaque élément afin de contrôler l'espace qui lui est alloué par rapport aux autres éléments. Par défaut, deux widgets identiques disposés dans une disposition linéaire auront la même taille, mais si le premier widget a un facteur d'étirement de 1 et le second widget un facteur d'étirement de 2, le premier widget obtiendra 1/3 de l'espace disponible, et le second 2/3.
QGraphicsLinearLayout calcule la distribution 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 de 0 pour tous les éléments ; un facteur de 0 signifie que l'élément n'a pas de facteur d'étirement défini ; en fait, cela revient à fixer le facteur d'étirement à 1. Le facteur d'étirement ne s'applique qu'à l'espace disponible dans le sens de la longueur de la mise en page (en suivant son orientation). Si vous souhaitez contrôler l'étirement horizontal et vertical de l'élément, vous pouvez utiliser QGraphicsGridLayout à la place.
QGraphicsLinearLayout comparé à d'autres mises en page
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 des fonctions membres
QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)
Construit 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)
Construit une instance de QGraphicsLinearLayout. Vous pouvez indiquer orientation pour la disposition, horizontale ou verticale, et parent est transmis au constructeur de QGraphicsLayout.
[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()
Détruit l'objet QGraphicsLinearLayout.
void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)
Cette fonction de commodité équivaut à appeler insertItem(-1, item).
void QGraphicsLinearLayout::addStretch(int stretch = 1)
Cette fonction de commodité équivaut à appeler insertStretch(-1, stretch).
Qt::Alignment QGraphicsLinearLayout::alignment(QGraphicsLayoutItem *item) const
Renvoie l'alignement pour 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é dans le cas où il y a plus d'espace disponible dans la mise en page que les widgets ne peuvent en occuper.
Voir aussi 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 à index, ou avant tout élément se trouvant actuellement à index.
Voir aussi addItem(), itemAt(), insertStretch() et setItemSpacing().
void QGraphicsLinearLayout::insertStretch(int index, int stretch = 1)
Insère une partie de stretch à l'adresse index, ou avant tout élément se trouvant actuellement à l'adresse index.
Voir aussi 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émente : QGraphicsLayout::itemAt(int i) const.
Lorsque l'itération se fait à partir de 0, elle renvoie les éléments dans l'ordre visuel.
qreal QGraphicsLinearLayout::itemSpacing(int index) const
Renvoie l'espacement après l'élément à index.
Voir aussi setItemSpacing().
Qt::Orientation QGraphicsLinearLayout::orientation() const
Renvoie l'orientation de la mise en page.
Voir également setOrientation().
[override virtual] void QGraphicsLinearLayout::removeAt(int index)
Réimplémente : QGraphicsLayout::removeAt(int index).
Supprime l'élément à 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 présentation sans la détruire. La propriété de item est transférée à l'appelant.
Voir aussi 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 aussi alignment() et invalidate().
[override virtual] void QGraphicsLinearLayout::setGeometry(const QRectF &rect)
Réimplémente : QGraphicsLayoutItem::setGeometry(const QRectF &rect).
void QGraphicsLinearLayout::setItemSpacing(int index, qreal spacing)
Définit l'espacement après l'élément à index à spacing.
Voir aussi itemSpacing().
void QGraphicsLinearLayout::setOrientation(Qt::Orientation orientation)
Modifier l'orientation de la mise en page sur orientation. La modification de l'orientation de la mise en page invalidera automatiquement la mise en page.
Voir également orientation().
void QGraphicsLinearLayout::setSpacing(qreal spacing)
Définit l'espacement de la mise en page à 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 invalidera la mise en page.
La valeur 0 attribuée à stretch supprime le facteur d'étirement de l'élément et équivaut en fait à la valeur 1 attribuée à stretch.
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 fait référence aux 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'a été attribué à l'élément.
Voir aussi 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.
