QGraphicsLinearLayout Class
Die Klasse „QGraphicsLinearLayout“ bietet ein horizontales oder vertikales Layout zur Verwaltung von Widgets in der Graphics View. Mehr...
| Kopfzeile: | #include <QGraphicsLinearLayout> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake: | QT += widgets |
| Erbt von: | QGraphicsLayout |
Öffentliche Funktionen
| 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 |
Neu implementierte öffentliche Funktionen
| 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 |
Ausführliche Beschreibung
Die Standardausrichtung für ein lineares Layout ist „ Qt::Horizontal “. Sie können eine vertikale Ausrichtung entweder durch Aufruf von ` setOrientation()` oder durch Übergabe von ` Qt::Vertical ` an den Konstruktor von `QGraphicsLinearLayout` festlegen.
Die gängigste Art, `QGraphicsLinearLayout` zu verwenden, besteht darin, ein Objekt auf dem Heap zu erstellen, dem Konstruktor ein übergeordnetes Widget zu übergeben und anschließend Widgets und Layouts durch Aufruf von ` addItem()` hinzuzufügen.
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);Alternativ müssen Sie, wenn Sie dem Konstruktor des Layouts kein übergeordnetes Widget übergeben, ` QGraphicsWidget::setLayout()` aufrufen, um dieses Layout als oberstes Layout für dieses Widget festzulegen; das Widget übernimmt dann die Verantwortung für das Layout.
Sie können einem linearen Layout Widgets, Layouts, Stretches (`addStretch()`, ` insertStretch()` oder ` setStretchFactor()`) und Abstände (`setItemSpacing()`) hinzufügen. Das Layout übernimmt die Eigentumsrechte an den Elementen. In einigen Fällen, in denen das Layout-Element auch von ` QGraphicsItem ` erbt (z. B. ` QGraphicsWidget`), kommt es zu einer Mehrdeutigkeit bei den Eigentumsrechten, da das Layout-Element zu zwei Eigentumshierarchien gehört. Informationen zur Behandlung dieses Problems finden Sie in der Dokumentation zu „ QGraphicsLayoutItem::setOwnedByLayout “ (). Sie können auf jedes Element im Layout zugreifen, indem Sie „ count “ () und „ itemAt “ () aufrufen. Durch den Aufruf von „ removeAt “ () oder „ removeItem “ () wird ein Element aus dem Layout entfernt, ohne es zu zerstören.
Größenhinweise und Größenrichtlinien in QGraphicsLinearLayout
QGraphicsLinearLayout berücksichtigt die Größenhinweise und Größenrichtlinien jedes Elements. Wenn das Layout mehr Platz enthält, als die Elemente ausfüllen können, wird jedes Element entsprechend der für dieses Element festgelegten Ausrichtung im Layout angeordnet. Sie können für jedes Element eine Ausrichtung festlegen, indem Sie „ setAlignment()“ aufrufen, und die Ausrichtung eines beliebigen Elements überprüfen, indem Sie „ alignment()“ aufrufen. Standardmäßig werden Elemente oben links ausgerichtet.
Abstand innerhalb von QGraphicsLinearLayout
Zwischen den Elementen verteilt das Layout etwas Platz. Die tatsächliche Größe des Abstands hängt vom aktuellen Stil des verwalteten Widgets ab, der übliche Abstand beträgt jedoch 4. Sie können auch einen eigenen Abstand festlegen, indem Sie ` setSpacing()` aufrufen, und den aktuellen Abstandswert abrufen, indem Sie ` spacing()` aufrufen. Wenn Sie individuelle Abstände für Ihre Elemente konfigurieren möchten, können Sie ` setItemSpacing()` aufrufen.
Stretch-Faktor in QGraphicsLinearLayout
Sie können jedem Element einen Stretch-Faktor zuweisen, um zu steuern, wie viel Platz es im Vergleich zu den anderen Elementen erhält. Standardmäßig haben zwei identische Widgets, die in einem linearen Layout angeordnet sind, dieselbe Größe. Wenn jedoch das erste Widget einen Stretch-Faktor von 1 und das zweite Widget einen Stretch-Faktor von 2 hat, erhält das erste Widget 1/3 des verfügbaren Platzes und das zweite 2/3.
QGraphicsLinearLayout berechnet die Größenverteilung, indem es die Stretch-Faktoren aller Elemente addiert und den verfügbaren Platz entsprechend aufteilt. Der Standard-Stretch-Faktor beträgt für alle Elemente 0; ein Faktor von 0 bedeutet, dass für das Element kein Stretch-Faktor definiert ist; dies entspricht faktisch der Einstellung eines Stretch-Faktors von 1. Der Stretch-Faktor gilt nur für den verfügbaren Platz in Längsrichtung des Layouts (entsprechend seiner Ausrichtung). Wenn Sie sowohl die horizontale als auch die vertikale Ausdehnung des Elements steuern möchten, können Sie stattdessen „ QGraphicsGridLayout “ verwenden.
QGraphicsLinearLayout im Vergleich zu anderen Layouts
QGraphicsLinearLayout ist QVBoxLayout und QHBoxLayout sehr ähnlich, wird jedoch im Gegensatz zu diesen Klassen zur Verwaltung von QGraphicsWidget und QGraphicsLayout anstelle von QWidget und QLayout verwendet.
Siehe auch QGraphicsGridLayout und QGraphicsWidget.
Dokumentation zu Mitgliedsfunktionen
QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)
Erstellt eine Instanz von `QGraphicsLinearLayout` mit der Ausrichtung „ Qt::Horizontal “. ` parent ` wird an den Konstruktor von ` QGraphicsLayout` übergeben.
QGraphicsLinearLayout::QGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent = nullptr)
Erstellt eine Instanz von `QGraphicsLinearLayout`. Sie können die ` orientation ` für das Layout übergeben – entweder „horizontal“ oder „vertical“ –, und ` parent ` wird an den Konstruktor von ` QGraphicsLayout` übergeben.
[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()
Löscht das „ QGraphicsLinearLayout “-Objekt.
void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)
Diese Hilfsfunktion entspricht dem Aufruf von ` insertItem(-1, item)`.
void QGraphicsLinearLayout::addStretch(int stretch = 1)
Diese Hilfsfunktion entspricht dem Aufruf von ` insertStretch(-1, stretch)`.
Qt::Alignment QGraphicsLinearLayout::alignment(QGraphicsLayoutItem *item) const
Gibt die Ausrichtung für „ item “ zurück. Die Standardausrichtung lautet „ Qt::AlignTop “ | „ Qt::AlignLeft “.
Die Ausrichtung bestimmt, wie das Element innerhalb des ihm zugewiesenen Platzes positioniert wird, falls im Layout mehr Platz verfügbar ist, als die Widgets einnehmen können.
Siehe auch ` setAlignment()`.
[override virtual] int QGraphicsLinearLayout::count() const
Implementiert: ` QGraphicsLayout::count()` const.
void QGraphicsLinearLayout::insertItem(int index, QGraphicsLayoutItem *item)
Fügt item in das Layout unter index ein oder vor jedes Element, das sich derzeit unter index befindet.
Siehe auch addItem(), itemAt(), insertStretch() und setItemSpacing().
void QGraphicsLinearLayout::insertStretch(int index, int stretch = 1)
Fügt einen Abschnitt aus stretch unter index oder vor einem beliebigen Eintrag ein, der sich derzeit unter index befindet.
Siehe auch addStretch(), setStretchFactor(), setItemSpacing() und insertItem().
[override virtual] void QGraphicsLinearLayout::invalidate()
Implementiert: QGraphicsLayout::invalidate().
[override virtual] QGraphicsLayoutItem *QGraphicsLinearLayout::itemAt(int index) const
Implementiert: ` QGraphicsLayout::itemAt(int i) const`.
Bei einer Iteration beginnend bei 0 gibt die Funktion die Elemente in der Reihenfolge zurück, in der sie visuell angeordnet sind.
qreal QGraphicsLinearLayout::itemSpacing(int index) const
Gibt den Abstand nach „item“ unter index zurück.
Siehe auch setItemSpacing().
Qt::Orientation QGraphicsLinearLayout::orientation() const
Gibt die Ausrichtung des Layouts zurück.
Siehe auch „ setOrientation()“.
[override virtual] void QGraphicsLinearLayout::removeAt(int index)
Implementiert: QGraphicsLayout::removeAt(int index).
Entfernt das Element unter index, ohne es zu zerstören. Das Eigentumsrecht an dem Element wird auf den Aufrufer übertragen.
Siehe auch „ removeItem()“ und „ insertItem()“.
void QGraphicsLinearLayout::removeItem(QGraphicsLayoutItem *item)
Entfernt „ item “ aus dem Layout, ohne es zu zerstören. Die Eigentumsrechte an „ item “ werden auf den Aufrufer übertragen.
Siehe auch „ removeAt()“ und „ insertItem()“.
void QGraphicsLinearLayout::setAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)
Legt die Ausrichtung von item auf alignment fest. Wenn sich die Ausrichtung von item ändert, wird das Layout automatisch ungültig.
Siehe auch alignment() und invalidate().
[override virtual] void QGraphicsLinearLayout::setGeometry(const QRectF &rect)
Implementiert: QGraphicsLayoutItem::setGeometry(const QRectF &rect).
void QGraphicsLinearLayout::setItemSpacing(int index, qreal spacing)
Legt den Abstand nach einem Element unter index auf spacing fest.
Siehe auch itemSpacing().
void QGraphicsLinearLayout::setOrientation(Qt::Orientation orientation)
Ändern Sie die Ausrichtung des Layouts auf „ orientation “. Durch das Ändern der Ausrichtung wird das Layout automatisch ungültig.
Siehe auch ` orientation()`.
void QGraphicsLinearLayout::setSpacing(qreal spacing)
Legt den Abstand des Layouts auf „ spacing “ fest. Der Abstand bezieht sich auf die vertikalen und horizontalen Abstände zwischen den Elementen.
Siehe auch spacing(), setItemSpacing(), setStretchFactor() und QGraphicsGridLayout::setSpacing().
void QGraphicsLinearLayout::setStretchFactor(QGraphicsLayoutItem *item, int stretch)
Legt den Stretch-Faktor für „ item “ auf „ stretch “ fest. Wenn sich der Stretch-Faktor eines Elements ändert, macht diese Funktion das Layout ungültig.
Die Einstellung von ` stretch ` auf 0 entfernt den Dehnungsfaktor aus dem Element und entspricht effektiv der Einstellung von ` stretch ` auf 1.
Siehe auch „ stretchFactor()“.
[override virtual] QSizeF QGraphicsLinearLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
Implementiert neu: ` QGraphicsLayoutItem::sizeHint` (`Qt::SizeHint which, const QSizeF &constraint) const`.
qreal QGraphicsLinearLayout::spacing() const
Gibt den Abstand des Layouts zurück. Der Abstand bezieht sich auf die vertikalen und horizontalen Abstände zwischen den Elementen.
Siehe auch „ setSpacing()“.
int QGraphicsLinearLayout::stretchFactor(QGraphicsLayoutItem *item) const
Gibt den Stretch-Faktor für „ item “ zurück. Der Standard-Stretch-Faktor ist 0, was bedeutet, dass dem Element kein Stretch-Faktor zugewiesen ist.
Siehe auch „ 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.
