Back to Qt.io
Contact Us Blog Download Qt
En esta página

QGraphicsLinearLayout Class

La clase QGraphicsLinearLayout proporciona un diseño horizontal o vertical para la gestión de widgets en la Vista Gráfica. Más...

Cabecera: #include <QGraphicsLinearLayout>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Hereda: 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 por defecto para un diseño lineal es Qt::Horizontal. Puedes elegir una orientación vertical llamando a setOrientation(), o pasando Qt::Vertical al constructor de QGraphicsLinearLayout.

La forma más común de usar QGraphicsLinearLayout es construir un objeto en el montón, pasando un widget padre al constructor, y luego 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);

Alternativamente, si no pasas un widget padre al constructor del layout, necesitarás llamar a QGraphicsWidget::setLayout() para establecer este layout como el layout de nivel superior para ese widget, el widget tomará posesión del layout.

Puedes añadir widgets, maquetas, tramos (addStretch(), insertStretch() o setStretchFactor()), y espaciados (setItemSpacing()) a una maqueta lineal. La maquetación se apropia de los elementos. En algunos casos, cuando el elemento de diseño también hereda de QGraphicsItem (como QGraphicsWidget) habrá una ambigüedad en la propiedad porque el elemento de diseño pertenece a dos jerarquías de propiedad. Consulte la documentación de QGraphicsLayoutItem::setOwnedByLayout() para saber cómo manejar esta situación. Puede acceder a cada elemento de la presentación llamando a count() y itemAt(). Llamar a removeAt() o removeItem() eliminará un elemento de la presentación, sin destruirlo.

Sugerencias y Políticas de Tamaño en QGraphicsLinearLayout

QGraphicsLinearLayout respeta las sugerencias y políticas de tamaño de cada ítem, y cuando la maqueta contiene más espacio del que los ítems pueden ocupar, cada ítem se ordena de acuerdo a la alineación de la maqueta para ese ítem. 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 arriba a la izquierda.

Espaciado dentro de QGraphicsLinearLayout

Entre los elementos, el diseño distribuye algo de espacio. La cantidad real de espacio depende del estilo actual del widget gestionado, pero el espaciado común es 4. También puedes establecer tu propio espaciado llamando a setSpacing(), y obtener el valor de espaciado actual llamando a spacing(). Si quieres configurar un espaciado individual para tus elementos, puedes llamar a setItemSpacing().

Factor de Estiramiento en QGraphicsLinearLayout

Puedes asignar un factor de estiramiento a cada ítem para controlar cuánto espacio obtendrá en comparación con los otros ítems. Por defecto, dos widgets idénticos dispuestos en un layout lineal tendrán el mismo tamaño, pero si el primer widget tiene un factor de estiramiento de 1 y el segundo widget tiene un factor de estiramiento de 2, el primer widget obtendrá 1/3 del espacio disponible, y el segundo obtendrá 2/3.

QGraphicsLinearLayout calcula la distribución de tamaños sumando los factores de estiramiento de todos los elementos, y luego dividiendo el espacio disponible en consecuencia. El factor de estiramiento por defecto es 0 para todos los elementos; un factor de 0 significa que el elemento no tiene ningún factor de estiramiento definido; efectivamente esto es lo mismo que establecer el factor de estiramiento a 1. El factor de estiramiento sólo se aplica al espacio disponible en la dirección longitudinal del diseño (siguiendo su orientación). Si desea controlar tanto el estiramiento horizontal como vertical del elemento, puede utilizar QGraphicsGridLayout en su lugar.

QGraphicsLinearLayout Comparado 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 miembro

QGraphicsLinearLayout::QGraphicsLinearLayout(QGraphicsLayoutItem *parent = nullptr)

Construye una instancia de QGraphicsLinearLayout usando la orientación Qt::Horizontal. parent se pasa al constructor de QGraphicsLayout.

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

Construye una instancia de QGraphicsLinearLayout. Puede pasar el orientation para el diseño, ya sea horizontal o vertical, y parent se pasa al constructor de QGraphicsLayout.

[virtual noexcept] QGraphicsLinearLayout::~QGraphicsLinearLayout()

Destruye el objeto QGraphicsLinearLayout.

void QGraphicsLinearLayout::addItem(QGraphicsLayoutItem *item)

Esta función es equivalente a llamar a insertItem(-1, item).

void QGraphicsLinearLayout::addStretch(int stretch = 1)

Esta función es equivalente a llamar a insertStretch(-1, stretch).

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

Devuelve la alineación para item. La alineación por defecto es Qt::AlignTop | Qt::AlignLeft.

La alineación decide cómo se posiciona el elemento dentro de su espacio 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 presentación en 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 tramo 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 de 0 en adelante, devolverá los elementos en el orden visual dispuesto.

qreal QGraphicsLinearLayout::itemSpacing(int index) const

Devuelve el espaciado después del elemento 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 índice).

Elimina el elemento en index sin destruirlo. La propiedad del elemento se transfiere a quien lo llama.

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 la persona que llama.

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

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

Establece la alineación de item con alignment. Si la alineación de item cambia, el diseño se invalida automáticamente.

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)

Cambie la orientación del diseño a orientation. Al cambiar la orientación del diseño, éste se invalidará automáticamente.

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 vertical y horizontal 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 el factor de estiramiento de un elemento cambia, esta función invalidará el diseño.

Establecer stretch a 0 elimina el factor de estiramiento del elemento, y es efectivamente equivalente a establecer stretch a 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 el elemento no tiene factor de estiramiento asignado.

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.