Ejemplo de diseño de flujo
Muestra cómo organizar los widgets para diferentes tamaños de ventana.
El diseño «Flow Layout» implementa un diseño que se adapta a diferentes tamaños de ventana. La ubicación de los widgets cambia en función del ancho de la ventana de la aplicación.

La clase `FlowLayout` utiliza principalmente ` QLayout ` y ` QWidgetItem`, mientras que la clase `Window` utiliza ` QWidget ` y ` QLabel`.
Para obtener más información, visita la página «Gestión de diseños ».
Ejecución del ejemplo
Puede ejecutar el ejemplo desde:
- Qt Creator
Abre el modo « Welcome » y selecciona el ejemplo en « Examples ». Para obtener más información, consulta Qt Creator: Tutorial: Compilar y ejecutar.
- Qt Extension for Visual Studio Code
Ejecute el comando « Qt: Open Qt examples » desde « Command Palette » y seleccione el ejemplo de la lista. Para obtener más información, consulte Qt Extension for Visual Studio Code: Tutorial: Compilar y ejecutar.
Definición de la clase FlowLayout
La clase ` FlowLayout ` hereda de ` QLayout`. Se trata de una clase de diseño personalizada que organiza sus widgets hijos tanto horizontal como verticalmente.
class FlowLayout : public QLayout
{
public:
explicit FlowLayout(QWidget *parent, int margin = -1, int hSpacing = -1, int vSpacing = -1);
explicit FlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);
~FlowLayout();
void addItem(QLayoutItem *item) override;
int horizontalSpacing() const;
int verticalSpacing() const;
Qt::Orientations expandingDirections() const override;
bool hasHeightForWidth() const override;
int heightForWidth(int) const override;
int count() const override;
QLayoutItem *itemAt(int index) const override;
QSize minimumSize() const override;
void setGeometry(const QRect &rect) override;
QSize sizeHint() const override;
QLayoutItem *takeAt(int index) override;
private:
int doLayout(const QRect &rect, bool testOnly) const;
int smartSpacing(QStyle::PixelMetric pm) const;
QList<QLayoutItem *> itemList;
int m_hSpace;
int m_vSpace;
};Reimplementamos las funciones heredadas de ` QLayout`. Estas funciones añaden elementos al diseño y gestionan su orientación y geometría.
También declaramos dos métodos privados: ` doLayout() ` y ` smartSpacing()`. ` doLayout() ` distribuye los elementos del diseño, mientras que la función ` smartSpacing() ` calcula el espaciado entre ellos.
Implementación de la clase FlowLayout
Empezamos por examinar el constructor:
FlowLayout::FlowLayout(QWidget *parent, int margin, int hSpacing, int vSpacing)
: QLayout(parent), m_hSpace(hSpacing), m_vSpace(vSpacing)
{
setContentsMargins(margin, margin, margin, margin);
}
FlowLayout::FlowLayout(int margin, int hSpacing, int vSpacing)
: m_hSpace(hSpacing), m_vSpace(vSpacing)
{
setContentsMargins(margin, margin, margin, margin);
}En el constructor llamamos a ` setContentsMargins() ` para establecer los márgenes izquierdo, superior, derecho e inferior. Por defecto, ` QLayout ` utiliza los valores proporcionados por el estilo actual (véase ` QStyle::PixelMetric`).
FlowLayout::~FlowLayout()
{
QLayoutItem *item;
while ((item = takeAt(0)))
delete item;
}En este ejemplo reimplementamos ` addItem()`, que es una función virtual pura. Al utilizar ` addItem() `, la propiedad de los elementos del diseño se transfiere al diseño, por lo que es responsabilidad de este eliminarlos.
void FlowLayout::addItem(QLayoutItem *item)
{
itemList.append(item);
}addItem() Se implementa para añadir elementos al diseño.
int FlowLayout::horizontalSpacing() const
{
if (m_hSpace >= 0) {
return m_hSpace;
} else {
return smartSpacing(QStyle::PM_LayoutHorizontalSpacing);
}
}
int FlowLayout::verticalSpacing() const
{
if (m_vSpace >= 0) {
return m_vSpace;
} else {
return smartSpacing(QStyle::PM_LayoutVerticalSpacing);
}
}Implementamos horizontalSpacing() y verticalSpacing() para obtener el espaciado entre los widgets dentro del diseño. Si el valor es menor o igual a 0, se utilizará este valor. De lo contrario, se llamará a smartSpacing() para calcular el espaciado.
int FlowLayout::count() const
{
return itemList.size();
}
QLayoutItem *FlowLayout::itemAt(int index) const
{
return itemList.value(index);
}
QLayoutItem *FlowLayout::takeAt(int index)
{
if (index >= 0 && index < itemList.size())
return itemList.takeAt(index);
return nullptr;
}A continuación, implementamos ` count() ` para devolver el número de elementos del diseño. Para navegar por la lista de elementos, utilizamos ` itemAt() ` y `takeAt()` para eliminar y recuperar elementos de la lista. Si se elimina un elemento, se renumerarán los elementos restantes. Las tres funciones son funciones virtuales puras de ` QLayout`.
Qt::Orientations FlowLayout::expandingDirections() const
{
return { };
}expandingDirections() Devuelve los valores de « Qt::Orientation» en los que el diseño puede utilizar más espacio que su « sizeHint() ».
bool FlowLayout::hasHeightForWidth() const
{
return true;
}
int FlowLayout::heightForWidth(int width) const
{
int height = doLayout(QRect(0, 0, width, 0), true);
return height;
}Para adaptarnos a los widgets cuya altura depende del ancho, implementamos ` heightForWidth()`. La función ` hasHeightForWidth() ` se utiliza para comprobar esta dependencia, y ` heightForWidth() ` pasa el ancho a ` doLayout() `, que a su vez utiliza el ancho como argumento para el rect de maquetación, es decir, los límites dentro de los cuales se distribuyen los elementos. Este rect no incluye el margen de maquetación (`layout margin()`).
void FlowLayout::setGeometry(const QRect &rect)
{
QLayout::setGeometry(rect);
doLayout(rect, false);
}
QSize FlowLayout::sizeHint() const
{
return minimumSize();
}
QSize FlowLayout::minimumSize() const
{
QSize size;
for (const QLayoutItem *item : std::as_const(itemList))
size = size.expandedTo(item->minimumSize());
const QMargins margins = contentsMargins();
size += QSize(margins.left() + margins.right(), margins.top() + margins.bottom());
return size;
}setGeometry() se utiliza normalmente para realizar el diseño propiamente dicho, es decir, para calcular la geometría de los elementos del diseño. En este ejemplo, llama a doLayout() y le pasa el rect de diseño.
sizeHint() devuelve el tamaño preferido del diseño y ` minimumSize() ` devuelve el tamaño mínimo del diseño.
int FlowLayout::doLayout(const QRect &rect, bool testOnly) const
{
int left, top, right, bottom;
getContentsMargins(&left, &top, &right, &bottom);
QRect effectiveRect = rect.adjusted(+left, +top, -right, -bottom);
int x = effectiveRect.x();
int y = effectiveRect.y();
int lineHeight = 0;doLayout() gestiona la disposición si ` horizontalSpacing() ` o ` verticalSpacing() ` no devuelven el valor por defecto. Utiliza ` getContentsMargins() ` para calcular el área disponible para los elementos de la disposición.
for (QLayoutItem *item : std::as_const(itemList)) {
const QWidget *wid = item->widget();
int spaceX = horizontalSpacing();
if (spaceX == -1)
spaceX = wid->style()->layoutSpacing(
QSizePolicy::PushButton, QSizePolicy::PushButton, Qt::Horizontal);
int spaceY = verticalSpacing();
if (spaceY == -1)
spaceY = wid->style()->layoutSpacing(
QSizePolicy::PushButton, QSizePolicy::PushButton, Qt::Vertical);A continuación, establece el espaciado adecuado para cada widget del diseño, en función del estilo actual.
int nextX = x + item->sizeHint().width() + spaceX;
if (nextX - spaceX > effectiveRect.right() && lineHeight > 0) {
x = effectiveRect.x();
y = y + lineHeight + spaceY;
nextX = x + item->sizeHint().width() + spaceX;
lineHeight = 0;
}
if (!testOnly)
item->setGeometry(QRect(QPoint(x, y), item->sizeHint()));
x = nextX;
lineHeight = qMax(lineHeight, item->sizeHint().height());
}
return y + lineHeight - rect.y() + bottom;
}A continuación, se calcula la posición de cada elemento en el diseño sumando el ancho del elemento y la altura de línea a las coordenadas x e y iniciales. Esto, a su vez, nos permite determinar si el siguiente elemento cabrá en la línea actual o si debe desplazarse a la siguiente. También calculamos la altura de la línea actual en función de la altura de los widgets.
int FlowLayout::smartSpacing(QStyle::PixelMetric pm) const
{
QObject *parent = this->parent();
if (!parent) {
return -1;
} else if (parent->isWidgetType()) {
QWidget *pw = static_cast<QWidget *>(parent);
return pw->style()->pixelMetric(pm, nullptr, pw);
} else {
return static_cast<QLayout *>(parent)->spacing();
}
}smartSpacing() Está diseñado para obtener el espaciado predeterminado tanto para los diseños de nivel superior como para los subdiseños. El espaciado predeterminado para los diseños de nivel superior, cuando el padre es un ` QWidget`, se determinará consultando el estilo. El espaciado predeterminado para los subdiseños, cuando el padre es un ` QLayout`, se determinará consultando el espaciado del diseño padre.
© 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.