En esta página

QGraphicsLayoutItem Class

La clase `QGraphicsLayoutItem` puede heredarse para permitir que los diseños gestionen tus elementos personalizados. Más información...

Encabezado: #include <QGraphicsLayoutItem>
CMake: find_package(Qt6 REQUIRED COMPONENTS Widgets)
target_link_libraries(mytarget PRIVATE Qt6::Widgets)
qmake: QT += widgets
Heredado por:

QGraphicsLayout y QGraphicsWidget

Funciones públicas

QGraphicsLayoutItem(QGraphicsLayoutItem *parent = nullptr, bool isLayout = false)
virtual ~QGraphicsLayoutItem()
QRectF contentsRect() const
QSizeF effectiveSizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
QRectF geometry() const
virtual void getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
QGraphicsItem *graphicsItem() const
(since 6.0) virtual bool isEmpty() const
bool isLayout() const
qreal maximumHeight() const
QSizeF maximumSize() const
qreal maximumWidth() const
qreal minimumHeight() const
QSizeF minimumSize() const
qreal minimumWidth() const
bool ownedByLayout() const
QGraphicsLayoutItem *parentLayoutItem() const
qreal preferredHeight() const
QSizeF preferredSize() const
qreal preferredWidth() const
virtual void setGeometry(const QRectF &rect)
void setMaximumHeight(qreal height)
void setMaximumSize(const QSizeF &size)
void setMaximumSize(qreal w, qreal h)
void setMaximumWidth(qreal width)
void setMinimumHeight(qreal height)
void setMinimumSize(const QSizeF &size)
void setMinimumSize(qreal w, qreal h)
void setMinimumWidth(qreal width)
void setParentLayoutItem(QGraphicsLayoutItem *parent)
void setPreferredHeight(qreal height)
void setPreferredSize(const QSizeF &size)
void setPreferredSize(qreal w, qreal h)
void setPreferredWidth(qreal width)
void setSizePolicy(const QSizePolicy &policy)
void setSizePolicy(QSizePolicy::Policy hPolicy, QSizePolicy::Policy vPolicy, QSizePolicy::ControlType controlType = QSizePolicy::DefaultType)
QSizePolicy sizePolicy() const
virtual void updateGeometry()

Funciones protegidas

void setGraphicsItem(QGraphicsItem *item)
void setOwnedByLayout(bool ownership)
virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const = 0

Descripción detallada

QGraphicsLayoutItem es una clase abstracta que define un conjunto de funciones virtuales que describen tamaños, políticas de tamaño y sugerencias de tamaño para cualquier objeto dispuesto mediante QGraphicsLayout. La API contiene funciones relevantes tanto para el propio elemento como para el usuario del mismo, ya que la mayoría de las funciones de QGraphicsLayoutItem también forman parte de la API pública de la subclase.

En la mayoría de los casos, las clases existentes que tienen en cuenta el diseño, como QGraphicsWidget y QGraphicsLayout, ya proporcionan la funcionalidad que necesitas. Sin embargo, crear subclases de estas clases te permitirá crear tanto elementos gráficos que funcionen bien con diseños (QGraphicsWidget) como diseños personalizados (QGraphicsLayout).

Creación de una subclase de QGraphicsLayoutItem

Si creas una subclase de `QGraphicsLayoutItem` y reimplementas sus funciones virtuales, permitirás que el diseño redimensione y posicione tu elemento junto con otros `QGraphicsLayoutItems`, incluidos ` QGraphicsWidget ` y ` QGraphicsLayout`.

Puede empezar por reimplementar funciones importantes: la función protegida ` sizeHint()` y la función pública ` setGeometry()`. Si desea que sus elementos detecten los cambios inmediatos en la geometría, también puede reimplementar ` updateGeometry()`.

La geometría, la indicación de tamaño y la política de tamaño afectan al tamaño y la posición del elemento. Al llamar a ` setGeometry()` siempre se redimensionará y reposicionará el elemento de forma inmediata. Normalmente, esta función la llama ` QGraphicsLayout ` una vez activado el diseño, pero también puede ser llamada por el usuario del elemento en cualquier momento.

La función sizeHint() devuelve las sugerencias de tamaño mínimo, preferido y máximo del elemento. Puedes anular estas propiedades llamando a setMinimumSize(), setPreferredSize() o setMaximumSize(). También puedes utilizar funciones como setMinimumWidth() o setMaximumHeight() para establecer únicamente el componente de anchura o altura, si lo deseas.

La función ` effectiveSizeHint()` (por su parte) devuelve una indicación de tamaño para cualquier ` Qt::SizeHint` dado y garantiza que el tamaño devuelto se ajusta a los tamaños mínimo y máximo y a las indicaciones de tamaño. Se puede establecer la política de tamaño vertical y horizontal del elemento llamando a ` setSizePolicy()`. El sistema de diseño utiliza la propiedad ` sizePolicy ` para describir cómo prefiere este elemento ampliarse o reducirse.

Anidamiento de QGraphicsLayoutItems

Los QGraphicsLayoutItems pueden anidarse dentro de otros QGraphicsLayoutItems, de forma similar a cómo los diseños pueden contener subdiseños. Esto se consigue pasando un puntero a QGraphicsLayoutItem al constructor protegido de QGraphicsLayoutItem, o bien llamando a setParentLayoutItem(). La función ` parentLayoutItem()` devuelve un puntero al elemento padre `layoutItem` del elemento. Si el elemento padre es ` nullptr ` o si el elemento padre no hereda de ` QGraphicsItem`, la función ` parentLayoutItem()` devuelve entonces ` nullptr`. La función ` isLayout()` devuelve ` true ` si la subclase de `QGraphicsLayoutItem` es en sí misma un diseño, o `false` en caso contrario.

Qt utiliza QGraphicsLayoutItem para proporcionar funcionalidad de diseño en el Graphics View Framework, pero en el futuro su uso podría extenderse a todo Qt.

Véase también QGraphicsWidget, QGraphicsLayout, QGraphicsLinearLayout y QGraphicsGridLayout.

Documentación de las funciones de miembro

QGraphicsLayoutItem::QGraphicsLayoutItem(QGraphicsLayoutItem *parent = nullptr, bool isLayout = false)

Crea el objeto `QGraphicsLayoutItem`. ` parent ` se convierte en el padre del objeto. Si ` isLayout ` es verdadero, el elemento es un diseño; en caso contrario, ` isLayout ` es falso.

[virtual noexcept] QGraphicsLayoutItem::~QGraphicsLayoutItem()

Elimina el objeto « QGraphicsLayoutItem ».

QRectF QGraphicsLayoutItem::contentsRect() const

Devuelve el rectángulo de contenido en coordenadas locales.

El rectángulo de contenido define el subrectángulo que utiliza un diseño asociado al organizar los subelementos. Esta función es una función de conveniencia que ajusta el método ` geometry()` del elemento según los márgenes de su contenido. Ten en cuenta que ` getContentsMargins()` es una función virtual que puedes reimplementar para devolver los márgenes de contenido del elemento.

Véanse también getContentsMargins() y geometry().

QSizeF QGraphicsLayoutItem::effectiveSizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

Devuelve la indicación de tamaño efectivo para este QGraphicsLayoutItem.

which es la sugerencia de tamaño en cuestión. ` constraint ` es un argumento opcional que define una restricción especial a la hora de calcular la sugerencia de tamaño efectiva. Por defecto, ` constraint ` es ` QSizeF` (-1, -1), lo que significa que no hay ninguna restricción para la sugerencia de tamaño.

Si deseas especificar la indicación de tamaño del widget para un ancho o una altura determinados, puedes indicar la dimensión fija en ` constraint`. Esto resulta útil para widgets que solo pueden expandirse vertical u horizontalmente y que necesitan establecer su ancho o su altura en un valor concreto.

Por ejemplo, un elemento de párrafo de texto que se ajuste a un ancho de columna de 200 puede crecer verticalmente. Puedes pasar ` QSizeF(200, -1)` como restricción para obtener una altura mínima, preferida y máxima adecuadas.

Se puede ajustar la sugerencia de tamaño efectivo reimplementando ` sizeHint()` en una subclase de ` QGraphicsLayoutItem `, o bien llamando a una de las siguientes funciones: ` setMinimumSize()`, ` setPreferredSize` o ` setMaximumSize()` (o una combinación de ambas).

Esta función almacena en caché cada una de las indicaciones de tamaño y garantiza que sizeHint() solo se llamará una vez por cada valor de which, a menos que no se haya especificado constraint y se haya llamado a updateGeometry().

Véase también sizeHint().

QRectF QGraphicsLayoutItem::geometry() const

Devuelve la geometría del elemento (por ejemplo, la posición y el tamaño) como un objeto de tipo « QRectF ». Esta función es equivalente a « QRectF » (pos(), size()).

Véase también setGeometry().

[virtual] void QGraphicsLayoutItem::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const

Esta función virtual proporciona los márgenes de contenido left, top, right y bottom para este QGraphicsLayoutItem. La implementación por defecto asume que todos los márgenes de contenido son 0. Los parámetros apuntan a valores almacenados en qreals. Si alguno de los punteros es nullptr, ese valor no se actualizará.

Véase también QGraphicsWidget::setContentsMargins().

QGraphicsItem *QGraphicsLayoutItem::graphicsItem() const

Devuelve el objeto « QGraphicsItem » que representa este elemento de diseño. En el caso de « QGraphicsWidget », devolverá el propio elemento. En el caso de los elementos personalizados, puede devolver un valor agregado.

Véase también setGraphicsItem().

[virtual, since 6.0] bool QGraphicsLayoutItem::isEmpty() const

Devuelve ` true ` si este elemento está vacío, es decir, si no tiene contenido y no debe ocupar espacio alguno.

La implementación por defecto devuelve ` true ` verdadero si el elemento se ha ocultado, a menos que su ` size policy ` tenga `retainSizeWhenHidden` establecido en true

Esta función se introdujo en Qt 6.0.

Véase también sizePolicy().

bool QGraphicsLayoutItem::isLayout() const

Devuelve « true » si este « QGraphicsLayoutItem » es un diseño (por ejemplo, si lo hereda un objeto que organiza otros objetos « QGraphicsLayoutItem »); en caso contrario, devuelve « false ».

Véase también QGraphicsLayout.

qreal QGraphicsLayoutItem::maximumHeight() const

Devuelve la altura máxima.

Véase también setMaximumHeight(), setMaximumSize() y maximumSize().

QSizeF QGraphicsLayoutItem::maximumSize() const

Devuelve el tamaño máximo.

Véase también setMaximumSize(), minimumSize(), preferredSize(), Qt::MaximumSize y sizeHint().

qreal QGraphicsLayoutItem::maximumWidth() const

Devuelve la anchura máxima.

Véase también setMaximumWidth(), setMaximumSize() y maximumSize().

qreal QGraphicsLayoutItem::minimumHeight() const

Devuelve la altura mínima.

Véase también setMinimumHeight(), setMinimumSize() y minimumSize().

QSizeF QGraphicsLayoutItem::minimumSize() const

Devuelve el tamaño mínimo.

Véase también setMinimumSize(), preferredSize(), maximumSize(), Qt::MinimumSize y sizeHint().

qreal QGraphicsLayoutItem::minimumWidth() const

Devuelve el ancho mínimo.

Véase también setMinimumWidth(), setMinimumSize() y minimumSize().

bool QGraphicsLayoutItem::ownedByLayout() const

Devuelve si un diseño debe eliminar este elemento en su destructor. Si el valor es verdadero, el diseño lo eliminará. Si es falso, se supone que otro objeto tiene la propiedad del mismo, y el diseño no eliminará este elemento.

Si el elemento hereda tanto de ` QGraphicsItem ` como de ` QGraphicsLayoutItem ` (como es el caso de ` QGraphicsWidget `), dicho elemento forma parte, en realidad, de dos jerarquías de propiedad. Esta propiedad indica qué debe hacer el diseño con sus elementos secundarios cuando se destruya. En el caso de QGraphicsWidget, es preferible que, cuando se elimine el diseño, no se eliminen sus elementos secundarios (ya que también forman parte de la jerarquía de elementos gráficos).

Por defecto, este valor se inicializa como «false» en QGraphicsLayoutItem, pero se sobrescribe mediante QGraphicsLayout para que devuelva «true». Esto se debe a que QGraphicsLayout no suele formar parte de la jerarquía de QGraphicsItem, por lo que el diseño padre debería eliminarlo. Las subclases pueden sobrescribir este comportamiento predeterminado llamando a setOwnedByLayout(true).

Véase también setOwnedByLayout().

QGraphicsLayoutItem *QGraphicsLayoutItem::parentLayoutItem() const

Devuelve el padre de este ` QGraphicsLayoutItem`, o ` nullptr ` si no hay ningún padre, o si el padre no hereda de ` QGraphicsLayoutItem ` (a menudo se utiliza `QGraphicsLayoutItem ` mediante herencia múltiple con clases derivadas de ` QObject`).

Véase también setParentLayoutItem().

qreal QGraphicsLayoutItem::preferredHeight() const

Devuelve la altura preferida.

Véase también setPreferredHeight(), setPreferredSize() y preferredSize().

QSizeF QGraphicsLayoutItem::preferredSize() const

Devuelve el tamaño preferido.

Véase también setPreferredSize(), minimumSize(), maximumSize(), Qt::PreferredSize y sizeHint().

qreal QGraphicsLayoutItem::preferredWidth() const

Devuelve el ancho preferido.

Véase también setPreferredWidth(), setPreferredSize() y preferredSize().

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

Esta función virtual establece la geometría de QGraphicsLayoutItem en rect, que está expresada en coordenadas del elemento padre (por ejemplo, la esquina superior izquierda de rect equivale a la posición del elemento en coordenadas del elemento padre).

Debes reimplementar esta función en una subclase de ` QGraphicsLayoutItem ` para recibir las actualizaciones de geometría. El diseño llamará a esta función cuando realice una reorganización.

Si rect se encuentra fuera de los límites de minimumSize y maximumSize, se ajustará al tamaño más cercano para que quede dentro de los límites permitidos.

Véase también ` geometry()`.

[protected] void QGraphicsLayoutItem::setGraphicsItem(QGraphicsItem *item)

Si el objeto ` QGraphicsLayoutItem ` representa un ` QGraphicsItem` y desea aprovechar las capacidades de reasignación automática de padres de ` QGraphicsLayout `, debe establecer este valor. Ten en cuenta que, si eliminas ` item ` y no eliminas el elemento de diseño, serás responsable de llamar a `setGraphicsItem(nullptr)` para evitar que quede un puntero colgante.

Véase también graphicsItem().

void QGraphicsLayoutItem::setMaximumHeight(qreal height)

Establece la altura máxima en height.

Véase también maximumHeight(), setMaximumSize() y maximumSize().

void QGraphicsLayoutItem::setMaximumSize(const QSizeF &size)

Establece el tamaño máximo en size. Esta propiedad anula sizeHint() para Qt::MaximumSize y garantiza que effectiveSizeHint() nunca devuelva un tamaño superior a size. Para desactivar el tamaño máximo, utiliza un tamaño no válido.

Véase también maximumSize(), minimumSize(), preferredSize(), Qt::MaximumSize y sizeHint().

void QGraphicsLayoutItem::setMaximumSize(qreal w, qreal h)

Esta función de conveniencia equivale a llamar a `setMaximumSize(QSizeF(w, h))`.

Véanse también maximumSize(), setMinimumSize(), setPreferredSize() y sizeHint().

void QGraphicsLayoutItem::setMaximumWidth(qreal width)

Establece el ancho máximo en width.

Véase también maximumWidth(), setMaximumSize() y maximumSize().

void QGraphicsLayoutItem::setMinimumHeight(qreal height)

Establece la altura mínima en height.

Véase también minimumHeight(), setMinimumSize() y minimumSize().

void QGraphicsLayoutItem::setMinimumSize(const QSizeF &size)

Establece el tamaño mínimo en size. Esta propiedad anula sizeHint() para Qt::MinimumSize y garantiza que effectiveSizeHint() nunca devuelva un tamaño inferior a size. Para desactivar el tamaño mínimo, utiliza un tamaño no válido.

Véase también minimumSize(), maximumSize(), preferredSize(), Qt::MinimumSize, sizeHint(), setMinimumWidth() y setMinimumHeight().

void QGraphicsLayoutItem::setMinimumSize(qreal w, qreal h)

Esta función de conveniencia equivale a llamar a setMinimumSize(QSizeF(w, h)).

Véanse también minimumSize(), setMaximumSize(), setPreferredSize() y sizeHint().

void QGraphicsLayoutItem::setMinimumWidth(qreal width)

Establece el ancho mínimo en width.

Véase también minimumWidth(), setMinimumSize() y minimumSize().

[protected] void QGraphicsLayoutItem::setOwnedByLayout(bool ownership)

Establece si un diseño debe eliminar este elemento en su destructor o no. El valor « ownership » debe ser «true» para que el diseño lo elimine.

Véase también ownedByLayout().

void QGraphicsLayoutItem::setParentLayoutItem(QGraphicsLayoutItem *parent)

Establece como elemento principal de este QGraphicsLayoutItem el parent.

Véase también parentLayoutItem().

void QGraphicsLayoutItem::setPreferredHeight(qreal height)

Establece la altura preferida en height.

Véase también preferredHeight(), preferredWidth(), setPreferredSize() y preferredSize().

void QGraphicsLayoutItem::setPreferredSize(const QSizeF &size)

Establece el tamaño preferido en size. Esta propiedad anula sizeHint() para Qt::PreferredSize y proporciona el valor por defecto para effectiveSizeHint(). Para desactivar el tamaño preferido, utiliza un tamaño no válido.

Véase también preferredSize(), minimumSize(), maximumSize(), Qt::PreferredSize y sizeHint().

void QGraphicsLayoutItem::setPreferredSize(qreal w, qreal h)

Esta función de conveniencia equivale a llamar a setPreferredSize(QSizeF(w, h)).

Véanse también preferredSize(), setMaximumSize(), setMinimumSize() y sizeHint().

void QGraphicsLayoutItem::setPreferredWidth(qreal width)

Establece el ancho preferido en width.

Véase también preferredWidth(), preferredHeight(), setPreferredSize() y preferredSize().

void QGraphicsLayoutItem::setSizePolicy(const QSizePolicy &policy)

Establece la política de tamaño en policy. La política de tamaño describe cómo debe ampliarse el elemento en sentido horizontal y vertical cuando se coloca en un diseño.

QGraphicsLayoutItemLa política de tamaño predeterminada de es (QSizePolicy::Fixed, QSizePolicy::Fixed, QSizePolicy::DefaultType), pero es habitual que las subclases modifiquen el valor predeterminado. Por ejemplo, QGraphicsWidget tiene como valor predeterminado (QSizePolicy::Preferred, QSizePolicy::Preferred, QSizePolicy::DefaultType).

Véase también sizePolicy() y QWidget::sizePolicy().

void QGraphicsLayoutItem::setSizePolicy(QSizePolicy::Policy hPolicy, QSizePolicy::Policy vPolicy, QSizePolicy::ControlType controlType = QSizePolicy::DefaultType)

Esta función equivale a llamar a `setSizePolicy(QSizePolicy(hPolicy, vPolicy, controlType))`.

Se trata de una función sobrecargada.

Véanse también sizePolicy() y QWidget::sizePolicy().

[pure virtual protected] QSizeF QGraphicsLayoutItem::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const

Esta función virtual pura devuelve la indicación de tamaño para ` which ` de ` QGraphicsLayoutItem`, utilizando la anchura o la altura de ` constraint ` para limitar la salida.

Reimplementa esta función en una subclase de ` QGraphicsLayoutItem ` para proporcionar las indicaciones de tamaño necesarias para tus elementos.

Véase también effectiveSizeHint().

QSizePolicy QGraphicsLayoutItem::sizePolicy() const

Devuelve la política de tamaño actual.

Véase también setSizePolicy() y QWidget::sizePolicy().

[virtual] void QGraphicsLayoutItem::updateGeometry()

Esta función virtual descarta cualquier información almacenada en caché sobre las indicaciones de tamaño. Debes llamar siempre a esta función si modificas el valor de retorno de la función sizeHint(). Las subclases deben llamar siempre a la implementación base al reimplementar esta función.

Véase también effectiveSizeHint().

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