Back to Qt.io
Contact Us Blog Download Qt

QGraphicsLinearLayout Class

Die Klasse QGraphicsLinearLayout bietet ein horizontales oder vertikales Layout zur Verwaltung von Widgets in der Grafikansicht. Mehr...

Kopfzeile: #include <QGraphicsLinearLayout>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Vererbt: 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

Reimplementierte ö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

Detaillierte Beschreibung

Die Standardausrichtung für ein lineares Layout ist Qt::Horizontal. Sie können eine vertikale Ausrichtung entweder durch den Aufruf von setOrientation() oder durch die Übergabe von Qt::Vertical an den Konstruktor von QGraphicsLinearLayout wählen.

Der gebräuchlichste Weg, QGraphicsLinearLayout zu verwenden, besteht darin, ein Objekt auf dem Heap zu konstruieren, dem Konstruktor ein übergeordnetes Widget zu übergeben und dann Widgets und Layouts durch den 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);

Wenn Sie kein übergeordnetes Widget an den Konstruktor des Layouts übergeben, müssen Sie alternativ QGraphicsWidget::setLayout() aufrufen, um dieses Layout als Layout der obersten Ebene für dieses Widget festzulegen; das Widget wird Eigentümer des Layouts.

Sie können einem linearen Layout Widgets, Layouts, Ausdehnungen (addStretch(), insertStretch() oder setStretchFactor()) und Abstände (setItemSpacing()) hinzufügen. Das Layout übernimmt das Eigentum an den Elementen. In einigen Fällen, in denen das Layoutelement auch von QGraphicsItem erbt (z. B. QGraphicsWidget), kommt es zu einer Mehrdeutigkeit bei der Eigentümerschaft, da das Layoutelement zu zwei Eigentümerhierarchien gehört. Siehe die Dokumentation von QGraphicsLayoutItem::setOwnedByLayout(), wie dies zu handhaben ist. 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ößen-Hinweise und Größen-Policies in QGraphicsLinearLayout

QGraphicsLinearLayout respektiert die Größenhinweise und Größenrichtlinien der einzelnen Elemente. Wenn das Layout mehr Platz enthält, als die Elemente füllen können, wird jedes Element entsprechend der Ausrichtung des Layouts für dieses Element angeordnet. Sie können eine Ausrichtung für jedes Element festlegen, indem Sie setAlignment() aufrufen, und die Ausrichtung für jedes Element überprüfen, indem Sie alignment() aufrufen. Standardmäßig sind die Elemente links oben ausgerichtet.

Abstände innerhalb von QGraphicsLinearLayout

Zwischen den Elementen verteilt das Layout etwas Platz. Der tatsächliche Abstand hängt vom aktuellen Stil des verwalteten Widgets ab, aber der übliche Abstand ist 4. Sie können auch Ihre eigenen Abstände durch den Aufruf von setSpacing() festlegen und den aktuellen Wert durch den Aufruf von spacing() abrufen. Wenn Sie individuelle Abstände für Ihre Elemente konfigurieren möchten, können Sie setItemSpacing() aufrufen.

Streckungsfaktor in QGraphicsLinearLayout

Sie können jedem Element einen Streckungsfaktor 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, die gleiche Größe, aber wenn das erste Widget einen Streckungsfaktor von 1 und das zweite Widget einen Streckungsfaktor 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 Dehnungsfaktoren aller Elemente addiert und dann den verfügbaren Platz entsprechend aufteilt. Der Standard-Dehnungsfaktor ist 0 für alle Elemente; ein Faktor von 0 bedeutet, dass das Element keinen definierten Dehnungsfaktor hat; effektiv ist dies dasselbe wie die Einstellung des Dehnungsfaktors auf 1. Der Dehnungsfaktor gilt nur für den verfügbaren Platz in der Längsrichtung des Layouts (entsprechend seiner Ausrichtung). Wenn Sie sowohl die horizontale als auch die vertikale Dehnung des Objekts steuern möchten, können Sie stattdessen QGraphicsGridLayout verwenden.

QGraphicsLinearLayout im Vergleich zu anderen Layouts

QGraphicsLinearLayout ist QVBoxLayout und QHBoxLayout sehr ähnlich, aber im Gegensatz zu diesen Klassen wird es verwendet, um QGraphicsWidget und QGraphicsLayout anstelle von QWidget und QLayout zu verwalten.

Siehe auch QGraphicsGridLayout und QGraphicsWidget.

Dokumentation der Mitgliedsfunktionen

QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)

Konstruiert eine QGraphicsLinearLayout-Instanz mit der Ausrichtung Qt::Horizontal. parent wird an den Konstruktor von QGraphicsLayout übergeben.

QGraphicsLinearLayout::QGraphicsLinearLayout(Qt::Orientation orientation, QGraphicsLayoutItem *parent = nullptr)

Konstruiert eine QGraphicsLinearLayout-Instanz. Sie können die orientation für das Layout übergeben, entweder horizontal oder vertikal, und parent wird an den Konstruktor von QGraphicsLayout übergeben.

[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()

Zerstört das Objekt QGraphicsLinearLayout.

void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von insertItem(-1, item).

void QGraphicsLinearLayout::addStretch(int stretch = 1)

Diese Komfortfunktion ist gleichbedeutend mit dem Aufruf von insertStretch(-1, stretch).

Qt::Alignment QGraphicsLinearLayout::alignment(QGraphicsLayoutItem *item) const

Gibt die Ausrichtung für item zurück. Die Standardausrichtung ist Qt::AlignTop | Qt::AlignLeft.

Die Ausrichtung bestimmt, wie das Element innerhalb des ihm zugewiesenen Platzes positioniert wird, wenn im Layout mehr Platz vorhanden ist, als die Widgets einnehmen können.

Siehe auch setAlignment().

[override virtual] int QGraphicsLinearLayout::count() const

Reimplements: QGraphicsLayout::count() const.

void QGraphicsLinearLayout::insertItem(int index, QGraphicsLayoutItem *item)

Fügt item in das Layout an index oder vor einem Element ein, das sich derzeit an index befindet.

Siehe auch addItem(), itemAt(), insertStretch(), und setItemSpacing().

void QGraphicsLinearLayout::insertStretch(int index, int stretch = 1)

Fügt einen Abschnitt von stretch unter index oder vor einem Element ein, das sich derzeit unter index befindet.

Siehe auch addStretch(), setStretchFactor(), setItemSpacing(), und insertItem().

[override virtual] void QGraphicsLinearLayout::invalidate()

Reimplements: QGraphicsLayout::invalidate().

[override virtual] QGraphicsLayoutItem *QGraphicsLinearLayout::itemAt(int index) const

Reimplements: QGraphicsLayout::itemAt(int i) const.

Bei der Iteration von 0 aufwärts werden die Elemente in der visuell angeordneten Reihenfolge zurückgegeben.

qreal QGraphicsLinearLayout::itemSpacing(int index) const

Gibt den Abstand nach dem Element auf index zurück.

Siehe auch setItemSpacing().

Qt::Orientation QGraphicsLinearLayout::orientation() const

Gibt die Layout-Ausrichtung zurück.

Siehe auch setOrientation().

[override virtual] void QGraphicsLinearLayout::removeAt(int index)

Reimplements: QGraphicsLayout::removeAt(int index).

Entfernt das Element auf index ohne es zu zerstören. Das Eigentum an dem Element geht auf den Aufrufer über.

Siehe auch removeItem() und insertItem().

void QGraphicsLinearLayout::removeItem(QGraphicsLayoutItem *item)

Entfernt item aus dem Layout, ohne es zu zerstören. Das Eigentum an item wird an den Aufrufer übertragen.

Siehe auch removeAt() und insertItem().

void QGraphicsLinearLayout::setAlignment(QGraphicsLayoutItem *item, Qt::Alignment alignment)

Setzt die Ausrichtung von item auf alignment. 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)

Reimplements: QGraphicsLayoutItem::setGeometry(const QRectF &rect).

void QGraphicsLinearLayout::setItemSpacing(int index, qreal spacing)

Setzt den Abstand nach dem Eintrag bei index auf spacing.

Siehe auch itemSpacing().

void QGraphicsLinearLayout::setOrientation(Qt::Orientation orientation)

Ändern Sie die Layout-Ausrichtung in orientation. Eine Änderung der Layout-Ausrichtung führt automatisch zur Ungültigkeit des Layouts.

Siehe auch orientation().

void QGraphicsLinearLayout::setSpacing(qreal spacing)

Setzt den Abstand des Layouts auf spacing. 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)

Setzt den Streckungsfaktor für item auf stretch. Wenn sich der Streckungsfaktor eines Objekts ändert, macht diese Funktion das Layout ungültig.

Wenn Sie stretch auf 0 setzen, wird der Streckungsfaktor des Objekts entfernt, was praktisch dem Setzen von stretch auf 1 entspricht.

Siehe auch stretchFactor().

[override virtual] QSizeF QGraphicsLinearLayout::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

Reimplements: QGraphicsLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const.

qreal QGraphicsLinearLayout::spacing() const

Gibt die Abstände des Layouts zurück. Die Abstände beziehen sich auf die vertikalen und horizontalen Abstände zwischen den Elementen.

Siehe auch setSpacing().

int QGraphicsLinearLayout::stretchFactor(QGraphicsLayoutItem *item) const

Gibt den Dehnungsfaktor für item zurück. Der Standard-Dehnungsfaktor ist 0, was bedeutet, dass dem Element kein Dehnungsfaktor zugewiesen ist.

Siehe auch setStretchFactor().

© 2025 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.