En esta página

QGraphicsLinearLayout Class

La clase QGraphicsLinearLayout proporciona un diseño horizontal o vertical para gestionar los widgets en Graphics View. Más información...

Encabezado: #include <QGraphicsLinearLayout>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Heredan: QGraphicsLayout

Funciones públicas

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

Funciones públicas reimplementadas

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

Descripción detallada

La orientación predeterminada de un diseño lineal es Qt::Horizontal. Se puede elegir una orientación vertical llamando a setOrientation() o pasando Qt::Vertical al constructor de QGraphicsLinearLayout.

La forma más habitual de utilizar QGraphicsLinearLayout es crear un objeto en el montón, pasando un widget padre al constructor, y a continuación añadir widgets y diseños llamando a 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);

Por otra parte, si no se pasa un widget padre al constructor del diseño, será necesario llamar a QGraphicsWidget::setLayout() para establecer este diseño como el diseño de nivel superior de ese widget; de este modo, el widget asumirá la propiedad del diseño.

Se pueden añadir widgets, diseños, elementos de extensión (addStretch(), insertStretch() o setStretchFactor()) y elementos de espaciado (setItemSpacing()) a un diseño lineal. El diseño asume la propiedad de los elementos. En algunos casos, cuando el elemento del diseño también hereda de QGraphicsItem (como QGraphicsWidget), se producirá una ambigüedad en la propiedad, ya que el elemento del diseño pertenece a dos jerarquías de propiedad. Consulte la documentación de QGraphicsLayoutItem::setOwnedByLayout() para saber cómo gestionar esto. Puede acceder a cada elemento del diseño llamando a count() y itemAt(). Al llamar a removeAt() o removeItem() se eliminará un elemento del diseño, sin destruirlo.

Indicaciones de tamaño y políticas de tamaño en `QGraphicsLinearLayout`

QGraphicsLinearLayout respeta las indicaciones de tamaño y las políticas de tamaño de cada elemento, y cuando el diseño contiene más espacio del que los elementos pueden ocupar, cada elemento se dispone según la alineación del diseño para ese elemento. Se puede establecer una alineación para cada elemento llamando a ` setAlignment()` y comprobar la alineación de cualquier elemento llamando a ` alignment()`. Por defecto, los elementos se alinean en la esquina superior izquierda.

Espaciado dentro de QGraphicsLinearLayout

El diseño distribuye algo de espacio entre los elementos. La cantidad real de espacio depende del estilo actual del widget gestionado, pero el espaciado habitual es 4. También puede establecer su propio espaciado llamando a setSpacing() y obtener el valor de espaciado actual llamando a spacing(). Si desea configurar el espaciado individual de sus elementos, puede llamar a setItemSpacing().

Factor de expansión en QGraphicsLinearLayout

Puedes asignar un factor de estiramiento a cada elemento para controlar cuánto espacio ocupará en comparación con los demás elementos. Por defecto, dos widgets idénticos dispuestos en un diseño lineal tendrán el mismo tamaño, pero si el primer widget tiene un factor de estiramiento de 1 y el segundo tiene un factor de estiramiento de 2, el primero ocupará 1/3 del espacio disponible y el segundo, 2/3.

QGraphicsLinearLayout calcula la distribución de los tamaños sumando los factores de estiramiento de todos los elementos y, a continuación, dividiendo el espacio disponible en consecuencia. El factor de estiramiento predeterminado es 0 para todos los elementos; un factor de 0 significa que el elemento no tiene ningún factor de estiramiento definido; en la práctica, esto equivale a establecer el factor de estiramiento en 1. El factor de estiramiento solo se aplica al espacio disponible en la dirección longitudinal del diseño (siguiendo su orientación). Si deseas controlar tanto el estiramiento horizontal como el vertical del elemento, puedes utilizar en su lugar un « QGraphicsGridLayout ».

QGraphicsLinearLayout en comparación con otros diseños

QGraphicsLinearLayout es muy similar a QVBoxLayout y QHBoxLayout, pero, a diferencia de estas clases, se utiliza para gestionar QGraphicsWidget y QGraphicsLayout en lugar de QWidget y QLayout.

Véase también QGraphicsGridLayout y QGraphicsWidget.

Documentación de las funciones de miembro

QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)

Crea una instancia de `QGraphicsLinearLayout` con una orientación « Qt::Horizontal ». Se pasa ` parent ` al constructor de ` QGraphicsLayout`.

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

Crea una instancia de `QGraphicsLinearLayout`. Se puede pasar la ` orientation ` para el diseño, ya sea horizontal o vertical, y ` parent ` se pasa al constructor de ` QGraphicsLayout`.

[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()

Elimina el objeto « QGraphicsLinearLayout ».

void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)

Esta función de conveniencia equivale a llamar a insertItem(-1, item).

void QGraphicsLinearLayout::addStretch(int stretch = 1)

Esta función de conveniencia equivale a llamar a ` insertStretch(-1, stretch)`.

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

Devuelve la alineación de item. La alineación predeterminada es Qt::AlignTop | Qt::AlignLeft.

La alineación determina cómo se coloca el elemento dentro del espacio que se le ha asignado, en el caso de que haya más espacio disponible en el diseño del que pueden ocupar los widgets.

Véase también setAlignment().

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

Reimplementa: ` QGraphicsLayout::count()` const.

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

Inserta item en la maquetación de index, o antes de cualquier elemento que se encuentre actualmente en index.

Véase también addItem(), itemAt(), insertStretch() y setItemSpacing().

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

Inserta un fragmento de stretch en index, o antes de cualquier elemento que se encuentre actualmente en index.

Véase también addStretch(), setStretchFactor(), setItemSpacing() y insertItem().

[override virtual] void QGraphicsLinearLayout::invalidate()

Reimplementa: QGraphicsLayout::invalidate().

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

Reimplementa: ` QGraphicsLayout::itemAt(int i) const`.

Al iterar desde 0 en adelante, devolverá los elementos en el orden en que aparecen en la interfaz visual.

qreal QGraphicsLinearLayout::itemSpacing(int index) const

Devuelve el espaciado que hay después de «item» en index.

Véase también setItemSpacing().

Qt::Orientation QGraphicsLinearLayout::orientation() const

Devuelve la orientación del diseño.

Véase también setOrientation().

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

Reimplementa: QGraphicsLayout::removeAt(int index).

Elimina el elemento situado en ` index ` sin destruirlo. La propiedad del elemento se transfiere a quien realiza la llamada.

Véase también removeItem() y insertItem().

void QGraphicsLinearLayout::removeItem(QGraphicsLayoutItem *item)

Elimina « item » del diseño sin destruirlo. La propiedad de « item » se transfiere a quien realiza la llamada.

Véase también removeAt() y insertItem().

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

Establece la alineación de item en alignment. Si cambia la alineación de item, el diseño queda automáticamente invalidado.

Véase también alignment() y invalidate().

[override virtual] void QGraphicsLinearLayout::setGeometry(const QRectF &rect)

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

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

Establece el espaciado después del elemento en index a spacing.

Véase también itemSpacing().

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

Cambia la orientación del diseño a « orientation ». Al cambiar la orientación del diseño, este quedará automáticamente invalidado.

Véase también orientation().

void QGraphicsLinearLayout::setSpacing(qreal spacing)

Establece el espaciado del diseño en spacing. El espaciado se refiere a las distancias verticales y horizontales entre los elementos.

Véase también spacing(), setItemSpacing(), setStretchFactor() y QGraphicsGridLayout::setSpacing().

void QGraphicsLinearLayout::setStretchFactor(QGraphicsLayoutItem *item, int stretch)

Establece el factor de estiramiento de item en stretch. Si cambia el factor de estiramiento de un elemento, esta función invalidará el diseño.

Al establecer ` stretch ` en 0 se elimina el factor de estiramiento del elemento, lo que equivale, en la práctica, a establecer ` stretch ` en 1.

Véase también stretchFactor().

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

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

qreal QGraphicsLinearLayout::spacing() const

Devuelve el espaciado del diseño. El espaciado se refiere a las distancias verticales y horizontales entre los elementos.

Véase también setSpacing().

int QGraphicsLinearLayout::stretchFactor(QGraphicsLayoutItem *item) const

Devuelve el factor de estiramiento de item. El factor de estiramiento por defecto es 0, lo que significa que al elemento no se le ha asignado ningún factor de estiramiento.

Véase también 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.