QGraphicsWidget Class
La clase `QGraphicsWidget` es la clase base de todos los elementos de widget de un ` QGraphicsScene`. Más información...
| Encabezado: | #include <QGraphicsWidget> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake: | QT += widgets |
| Heredado de: | QGraphicsObject y QGraphicsLayoutItem |
| Heredado por: |
Tipos públicos
| enum { Type } |
Propiedades
|
|
Funciones públicas
| QGraphicsWidget(QGraphicsItem *parent = nullptr, Qt::WindowFlags wFlags = Qt::WindowFlags()) | |
| virtual | ~QGraphicsWidget() |
| QList<QAction *> | actions() const |
| void | addAction(QAction *action) |
| void | addActions(const QList<QAction *> &actions) |
| void | adjustSize() |
| bool | autoFillBackground() const |
| Qt::FocusPolicy | focusPolicy() const |
| QGraphicsWidget * | focusWidget() const |
| QFont | font() const |
| void | getWindowFrameMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const |
| int | grabShortcut(const QKeySequence &sequence, Qt::ShortcutContext context = Qt::WindowShortcut) |
| void | insertAction(QAction *before, QAction *action) |
| void | insertActions(QAction *before, const QList<QAction *> &actions) |
| bool | isActiveWindow() const |
| QGraphicsLayout * | layout() const |
| Qt::LayoutDirection | layoutDirection() const |
| virtual void | paintWindowFrame(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) |
| QPalette | palette() const |
| QRectF | rect() const |
| void | releaseShortcut(int id) |
| void | removeAction(QAction *action) |
| void | resize(const QSizeF &size) |
| void | resize(qreal w, qreal h) |
| void | setAttribute(Qt::WidgetAttribute attribute, bool on = true) |
| void | setAutoFillBackground(bool enabled) |
| void | setContentsMargins(QMarginsF margins) |
| void | setContentsMargins(qreal left, qreal top, qreal right, qreal bottom) |
| void | setFocusPolicy(Qt::FocusPolicy policy) |
| void | setFont(const QFont &font) |
| void | setGeometry(qreal x, qreal y, qreal w, qreal h) |
| void | setLayout(QGraphicsLayout *layout) |
| void | setLayoutDirection(Qt::LayoutDirection direction) |
| void | setPalette(const QPalette &palette) |
| void | setShortcutAutoRepeat(int id, bool enabled = true) |
| void | setShortcutEnabled(int id, bool enabled = true) |
| void | setStyle(QStyle *style) |
| void | setWindowFlags(Qt::WindowFlags wFlags) |
| void | setWindowFrameMargins(QMarginsF margins) |
| void | setWindowFrameMargins(qreal left, qreal top, qreal right, qreal bottom) |
| void | setWindowTitle(const QString &title) |
| QSizeF | size() const |
| QStyle * | style() const |
| bool | testAttribute(Qt::WidgetAttribute attribute) const |
| void | unsetLayoutDirection() |
| void | unsetWindowFrameMargins() |
| Qt::WindowFlags | windowFlags() const |
| QRectF | windowFrameGeometry() const |
| QRectF | windowFrameRect() const |
| QString | windowTitle() const |
| Qt::WindowType | windowType() const |
Funciones públicas reimplementadas
| virtual QRectF | boundingRect() const override |
| virtual void | getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const override |
| virtual void | paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override |
| virtual void | setGeometry(const QRectF &rect) override |
| virtual QPainterPath | shape() const override |
| virtual int | type() const override |
Ranuras públicas
| bool | close() |
Señales
| void | geometryChanged() |
Miembros públicos estáticos
| void | setTabOrder(QGraphicsWidget *first, QGraphicsWidget *second) |
Funciones protegidas
| virtual void | changeEvent(QEvent *event) |
| virtual void | closeEvent(QCloseEvent *event) |
| virtual bool | focusNextPrevChild(bool next) |
| virtual void | grabKeyboardEvent(QEvent *event) |
| virtual void | grabMouseEvent(QEvent *event) |
| virtual void | hideEvent(QHideEvent *event) |
| virtual void | initStyleOption(QStyleOption *option) const |
| virtual void | moveEvent(QGraphicsSceneMoveEvent *event) |
| virtual void | polishEvent() |
| virtual void | resizeEvent(QGraphicsSceneResizeEvent *event) |
| virtual void | showEvent(QShowEvent *event) |
| virtual void | ungrabKeyboardEvent(QEvent *event) |
| virtual void | ungrabMouseEvent(QEvent *event) |
| virtual bool | windowFrameEvent(QEvent *event) |
| virtual Qt::WindowFrameSection | windowFrameSectionAt(const QPointF &pos) const |
Funciones protegidas reimplementadas
| virtual bool | event(QEvent *event) override |
| virtual void | focusInEvent(QFocusEvent *event) override |
| virtual void | focusOutEvent(QFocusEvent *event) override |
| virtual void | hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override |
| virtual void | hoverMoveEvent(QGraphicsSceneHoverEvent *event) override |
| virtual QVariant | itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) override |
| virtual bool | sceneEvent(QEvent *event) override |
| virtual QSizeF | sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const override |
| virtual void | updateGeometry() override |
Descripción detallada
QGraphicsWidget es un elemento base ampliado que proporciona funcionalidad adicional con respecto a QGraphicsItem. Es similar a QWidget en muchos aspectos:
- Proporciona un ` palette`, un ` font ` y un ` style()`.
- Tiene definida una función geometry().
- Admite diseños con setLayout() y layout().
- Admite atajos y acciones mediante grabShortcut() y insertAction()
A diferencia de QGraphicsItem, QGraphicsWidget no es una clase abstracta; se pueden crear instancias de QGraphicsWidget sin necesidad de crear una subclase. Este enfoque resulta útil para widgets cuyo único propósito es organizar widgets hijos en un diseño.
QGraphicsWidget puede utilizarse como elemento base para crear un elemento personalizado si se necesita una gestión avanzada del foco de entrada, por ejemplo, el foco y la activación mediante la tecla Tab, o bien diseños.
Dado que QGraphicsWidget se asemeja a QWidget y tiene una API similar, resulta más fácil portar un widget desde QWidget a QGraphicsWidget, en lugar de hacerlo desde QGraphicsItem.
Nota: Los widgets basados enQWidget pueden integrarse directamente en un QGraphicsScene utilizando QGraphicsProxyWidget.
Las diferencias más notables entre QGraphicsWidget y QWidget son:
| QGraphicsWidget | QWidget |
|---|---|
| Las coordenadas y la geometría se definen con qreals (tipos double o float, dependiendo de la plataforma). | QWidget Utiliza geometría entera (QPoint, QRect). |
| El widget ya está visible por defecto; no es necesario llamar a ` show()` para mostrarlo. | QWidget Está oculto por defecto hasta que se llame a show(). |
| Se admite un subconjunto de atributos de widget. | Se admiten todos los atributos de los widgets. |
| El estilo predeterminado de un elemento de nivel superior es QGraphicsScene::style | El estilo predeterminado de un widget de nivel superior es QApplication::style |
| Graphics View proporciona un marco de trabajo personalizado de arrastrar y soltar, diferente de QWidget. | Marco estándar de «arrastrar y soltar». |
| Los elementos de los widgets no admiten la modalidad. | Compatibilidad total con la modalidad. |
QGraphicsWidget admite un subconjunto de los atributos de los widgets de Qt (Qt::WidgetAttribute), tal y como se muestra en la tabla siguiente. Cualquier atributo que no figure en esta tabla no es compatible o no se utiliza.
| Atributo del widget | Uso |
|---|---|
| Qt::WA_SetLayoutDirection | Se establece mediante ` setLayoutDirection()` y se desactiva mediante ` unsetLayoutDirection()`. Puedes comprobar este atributo para ver si al widget se le ha asignado explícitamente un ` layoutDirection`. Si el atributo no está establecido, se hereda el ` layoutDirection()`. |
| Qt::WA_RightToLeft | Se activa y desactiva mediante setLayoutDirection(). Se hereda del padre o de la escena. Si está activado, el diseño del widget ordenará los widgets dispuestos horizontalmente de derecha a izquierda. |
| Qt::WA_SetStyle | Se establece y se desactiva mediante setStyle(). Si este atributo está establecido, se ha asignado explícitamente un estilo al widget. Si no está establecido, el widget utilizará el estilo de la escena o de la aplicación. |
| Qt::WA_Resized | Se establece mediante setGeometry() y resize(). |
| Qt::WA_SetPalette | Se establece mediante ` setPalette()` (). |
| Qt::WA_SetFont | Se establece mediante setFont(). |
| Qt::WA_WindowPropagation | Permite la propagación a los widgets de ventana. |
Aunque `QGraphicsWidget` hereda tanto de ` QObject ` como de ` QGraphicsItem`, debes utilizar las funciones proporcionadas por ` QGraphicsItem`, y no ` QObject`, para gestionar las relaciones entre elementos padres e hijos. Estas funciones controlan el orden de superposición de los elementos, así como su propiedad.
Nota: La función ` QObject::parent()` debería devolver siempre ` nullptr ` para los `QGraphicsWidgets`, pero esta norma no está definida de forma estricta.
Véase también ` QGraphicsProxyWidget`, ` QGraphicsItem` y «Widgets y diseños».
Documentación sobre los tipos de miembros
[anonymous] enum
El valor devuelto por la función virtual ` type()`.
| Constante | Valor | Descripción |
|---|---|---|
QGraphicsWidget::Type | 11 | Un elemento de widget gráfico |
Documentación de la propiedad
autoFillBackground : bool
Esta propiedad determina si el fondo del widget se rellena automáticamente
Si se habilita, esta propiedad hará que Qt rellene el fondo del widget antes de invocar el método paint(). El color utilizado viene definido por el rol de color « QPalette::Window » del palette del widget.
Además, las ventanas siempre se rellenan con QPalette::Window, a menos que se hayan establecido los atributos WA_OpaquePaintEvent o WA_NoSystemBackground.
Por defecto, esta propiedad es false.
Funciones de acceso:
| bool | autoFillBackground() const |
| void | setAutoFillBackground(bool enabled) |
Véase también « Qt::WA_OpaquePaintEvent » y « Qt::WA_NoSystemBackground ».
focusPolicy : Qt::FocusPolicy
Esta propiedad define la forma en que el widget acepta el foco del teclado
La política de foco es Qt::TabFocus si el widget acepta el foco del teclado mediante la tecla Tab, Qt::ClickFocus si lo acepta al hacer clic, Qt::StrongFocus si acepta ambas formas, y Qt::NoFocus (por defecto) si no acepta el foco en absoluto.
Debes habilitar el foco del teclado para un widget si este procesa eventos de teclado. Esto se suele hacer desde el constructor del widget. Por ejemplo, el constructor QLineEdit llama a setFocusPolicy(Qt::StrongFocus).
Si habilitas una política de foco (es decir, que no sea Qt::NoFocus), QGraphicsWidget habilitará automáticamente el indicador ItemIsFocusable. Al establecer Qt::NoFocus en un widget, se borrará el indicador ItemIsFocusable. Si el widget tiene actualmente el foco del teclado, lo perderá automáticamente.
Funciones de acceso:
| Qt::FocusPolicy | focusPolicy() const |
| void | setFocusPolicy(Qt::FocusPolicy policy) |
Véase también focusInEvent(), focusOutEvent(), keyPressEvent(), keyReleaseEvent() y enabled.
font : QFont
Esta propiedad contiene la fuente de los widgets
Esta propiedad proporciona la fuente del widget.
QFont Consta de propiedades de fuente que se han definido explícitamente y de propiedades heredadas implícitamente del widget padre. Por lo tanto, font() puede devolver una fuente diferente a la establecida con setFont(). Este esquema permite definir entradas individuales en una fuente sin afectar a las entradas heredadas de la misma.
Cuando cambia la fuente de un widget, este resuelve sus entradas en función de su widget padre. Si el widget no tiene un widget padre, resuelve sus entradas en función de la escena. A continuación, el widget se envía a sí mismo un evento « FontChange » y notifica a todos sus descendientes para que estos también puedan resolver sus fuentes.
Por defecto, esta propiedad contiene la fuente predeterminada de la aplicación.
Funciones de acceso:
| QFont | font() const |
| void | setFont(const QFont &font) |
Véase también QApplication::font(), QGraphicsScene::font y QFont::resolve().
geometry : QRectF
Esta propiedad contiene la geometría del widget
Establece la geometría del elemento en rect. La posición y el tamaño del elemento se modifican al llamar a esta función. Primero se desplaza el elemento y, a continuación, se cambia su tamaño.
Un efecto secundario de llamar a esta función es que el widget recibirá un evento de desplazamiento y un evento de redimensionamiento. Además, si el widget tiene asignado un diseño, este se activará.
Funciones de acceso:
| virtual void | setGeometry(const QRectF &rect) override |
| void | setGeometry(qreal x, qreal y, qreal w, qreal h) |
Señal de notificación:
| void | geometryChanged() |
Véase también « geometry()» y « resize()».
layout : QGraphicsLayout*
Esta propiedad define el diseño del widget
Cualquier gestor de diseño existente se elimina antes de asignar el nuevo diseño. Si layout es nullptr, el widget queda sin diseño. Las geometrías de los subwidgets existentes no se verán afectadas.
QGraphicsWidget layout pasa a ser el padre de este elemento.
Todos los widgets que actualmente están gestionados por layout o por cualquiera de sus subdiseños pasan automáticamente a estar subordinados a este elemento. A continuación, el diseño se invalida y las geometrías de los widgets hijos se ajustan de acuerdo con los métodos geometry() y contentsMargins() de este elemento. Los hijos que no estén gestionados explícitamente por layout no se ven afectados por el diseño una vez que este se ha asignado a este widget.
Si ningún diseño gestiona actualmente este widget, layout() devolverá « nullptr ».
Funciones de acceso:
layoutDirection : Qt::LayoutDirection
Esta propiedad determina la dirección de maquetación de este widget.
Esta propiedad modifica el atributo « Qt::WA_RightToLeft » de este widget y de todos sus descendientes. También establece el atributo « Qt::WA_SetLayoutDirection » de este widget.
La dirección de diseño del widget determina el orden en el que el gestor de diseño dispone horizontalmente los subwidgets de este widget. El valor por defecto depende del idioma y la configuración regional de la aplicación, y suele coincidir con la dirección en la que se leen y escriben las palabras. Con ` Qt::LeftToRight`, el diseño comienza a colocar los subwidgets desde el lado izquierdo de este widget hacia la derecha. ` Qt::RightToLeft ` hace lo contrario: el diseño colocará los widgets empezando por el borde derecho y avanzando hacia la izquierda.
Los subwidgets heredan su dirección de diseño del padre. Los elementos de widget de nivel superior heredan su dirección de diseño de QGraphicsScene::layoutDirection. Si se cambia la dirección de diseño de un widget llamando a setLayoutDirection(), el widget se enviará a sí mismo un evento LayoutDirectionChange y, a continuación, propagará la nueva dirección de diseño a todos sus descendientes.
Funciones de acceso:
| Qt::LayoutDirection | layoutDirection() const |
| void | setLayoutDirection(Qt::LayoutDirection direction) |
| void | unsetLayoutDirection() |
Véase también QWidget::layoutDirection y QApplication::layoutDirection.
maximumSize : QSizeF
Esta propiedad indica el tamaño máximo del widget
Véase también setMaximumSize(), maximumSize(), minimumSize y preferredSize.
minimumSize : QSizeF
Esta propiedad indica el tamaño mínimo del widget
Véase también setMinimumSize(), minimumSize(), preferredSize y maximumSize.
palette : QPalette
Esta propiedad contiene la paleta del widget
Esta propiedad proporciona la paleta del widget. La paleta proporciona colores y pinceles para grupos de colores (p. ej., QPalette::Button) y estados (p. ej., QPalette::Inactive), definiendo de forma aproximada el aspecto general del widget y de sus elementos hijos.
QPalette Consta de grupos de colores que se han definido explícitamente y de grupos que se heredan implícitamente del widget padre. Por este motivo, palette() puede devolver una paleta diferente a la que se ha establecido con setPalette(). Este esquema permite definir entradas individuales en una paleta sin afectar a las entradas heredadas de la misma.
Cuando cambia la paleta de un widget, este resuelve sus entradas en función de su widget padre o, si no tiene ningún widget padre, en función de la escena. A continuación, se envía a sí mismo un evento « PaletteChange » y notifica a todos sus descendientes para que estos también puedan resolver sus paletas.
Por defecto, esta propiedad contiene la paleta predeterminada de la aplicación.
Funciones de acceso:
| QPalette | palette() const |
| void | setPalette(const QPalette &palette) |
Véase también QGuiApplication::palette(), QGraphicsScene::palette y QPalette::resolve().
preferredSize : QSizeF
Esta propiedad contiene el tamaño preferido del widget
Véase también setPreferredSize(), preferredSize(), minimumSize y maximumSize.
size : QSizeF
Esta propiedad contiene el tamaño del widget
Al llamar a resize(), el widget se redimensiona a un size delimitado por minimumSize() y maximumSize(). Esta propiedad solo afecta al ancho y la altura del widget (por ejemplo, sus bordes derecho e inferior); la posición del widget y su esquina superior izquierda no se ven afectadas.
Al cambiar el tamaño de un widget, este recibe inmediatamente un evento GraphicsSceneResize con el tamaño anterior y el nuevo del widget. Si el widget tiene asignado un diseño cuando se produce este evento, dicho diseño se activará y actualizará automáticamente la geometría de cualquier widget secundario.
Esta propiedad no afecta a ningún diseño del widget padre. Si el propio widget está gestionado por un diseño padre —por ejemplo, si tiene un widget padre al que se le ha asignado un diseño—, dicho diseño no se activará.
Por defecto, esta propiedad contiene un tamaño con anchura y altura iguales a cero.
Funciones de acceso:
| QSizeF | size() const |
| void | resize(const QSizeF &size) |
| void | resize(qreal w, qreal h) |
Señal de notificador:
| void | geometryChanged() |
Véase también setGeometry(), QGraphicsSceneResizeEvent y QGraphicsLayout.
sizePolicy : QSizePolicy
Esta propiedad define la política de tamaño del widget
Véase también sizePolicy(), setSizePolicy() y QWidget::sizePolicy().
windowFlags : Qt::WindowFlags
Esta propiedad contiene los indicadores de la ventana del widget
Los indicadores de ventana son una combinación de un tipo de ventana (por ejemplo, Qt::Dialog) y varios indicadores que proporcionan información sobre el comportamiento de la ventana. El comportamiento depende de la plataforma.
Por defecto, esta propiedad no contiene indicadores de ventana.
Las ventanas son paneles. Si se establece el indicador « Qt::Window », el indicador «ItemIsPanel» se establecerá automáticamente. Si se desactiva el indicador « Qt::Window », el indicador «ItemIsPanel» también se desactivará. Ten en cuenta que el indicador «ItemIsPanel» se puede establecer independientemente de « Qt::Window ».
Funciones de acceso:
| Qt::WindowFlags | windowFlags() const |
| void | setWindowFlags(Qt::WindowFlags wFlags) |
Véanse también isWindow() y isPanel().
windowTitle : QString
Esta propiedad contiene el título (etiqueta) de la ventana.
Esta propiedad solo se utiliza para ventanas.
Por defecto, si no se ha establecido ningún título, esta propiedad contiene una cadena vacía.
Funciones de acceso:
| QString | windowTitle() const |
| void | setWindowTitle(const QString &title) |
Documentación de las funciones de miembro
QGraphicsWidget::QGraphicsWidget(QGraphicsItem *parent = nullptr, Qt::WindowFlags wFlags = Qt::WindowFlags())
Crea una instancia de QGraphicsWidget. El argumento opcional « parent » se pasa al constructor de « QGraphicsItem ». El argumento opcional « wFlags » especifica los indicadores de ventana del widget (por ejemplo, si el widget debe ser una ventana, una herramienta, una ventana emergente, etc.).
[virtual noexcept] QGraphicsWidget::~QGraphicsWidget()
Elimina la instancia de « QGraphicsWidget ».
QList<QAction *> QGraphicsWidget::actions() const
Devuelve la lista (que puede estar vacía) de las acciones de este widget.
Véase también insertAction(), removeAction(), QWidget::actions(), QAction::associatedWidgets() y QAction::associatedGraphicsWidgets().
void QGraphicsWidget::addAction(QAction *action)
Añade la acción « action » a la lista de acciones de este widget.
Todos los QGraphicsWidgets tienen una lista de « QAction», aunque pueden representarse gráficamente de muchas formas diferentes. El uso predeterminado de la lista « QAction » (tal y como la devuelve « actions()») es crear un contexto « QMenu ».
Un QGraphicsWidget solo debe contener una instancia de cada acción, y añadir una acción que ya tenga no hará que dicha acción aparezca dos veces en el widget.
Véase también removeAction(), insertAction(), actions() y QWidget::addAction().
void QGraphicsWidget::addActions(const QList<QAction *> &actions)
Añade las acciones « actions » a la lista de acciones de este widget.
Véase también removeAction(), QMenu, addAction() y QWidget::addActions().
void QGraphicsWidget::adjustSize()
Ajusta el tamaño del widget a su indicación de tamaño preferido efectivo.
Esta función se invoca de forma implícita cuando el elemento se muestra por primera vez.
Véase también effectiveSizeHint() y Qt::MinimumSize.
[override virtual] QRectF QGraphicsWidget::boundingRect() const
Reimplementa: ` QGraphicsItem::boundingRect()` const.
[virtual protected] void QGraphicsWidget::changeEvent(QEvent *event)
Este controlador de eventos se puede reimplementar para gestionar los cambios de estado.
El estado que se modifica en este evento se puede recuperar mediante event.
Los eventos de cambio incluyen: QEvent::ActivationChange, QEvent::EnabledChange, QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange, QEvent::ParentChange, QEvent::LayoutDirectionChange y QEvent::ContentsRectChange.
[slot] bool QGraphicsWidget::close()
Llama a esta función para cerrar el widget.
Devuelve ` true ` si se ha cerrado el widget; en caso contrario, devuelve ` false`. Esta ranura enviará primero un ` QCloseEvent ` al widget, que podrá aceptar o no el evento. Si se ignora el evento, no ocurre nada. Si se acepta el evento, se ejecutará ` hide()` en el widget.
Si el widget tiene establecido el atributo « Qt::WA_DeleteOnClose », se eliminará.
[virtual protected] void QGraphicsWidget::closeEvent(QCloseEvent *event)
Este controlador de eventos, para event, puede reimplementarse en una subclase para recibir eventos de cierre del widget. La implementación por defecto acepta el evento.
Véase también close() y QCloseEvent.
[override virtual protected] bool QGraphicsWidget::event(QEvent *event)
Reimplementa: QGraphicsObject::event(QEvent *ev).
Gestiona el event. QGraphicsWidget gestiona los siguientes eventos:
| Evento | Uso |
|---|---|
| Polaco | Se envía al widget algún tiempo después de que se haya mostrado. |
| GraphicsSceneMove | Se envía al widget después de que haya cambiado su posición local. |
| GraphicsSceneResize | Se envía al widget después de que haya cambiado su tamaño. |
| Show | Se envía al widget antes de que se muestre. |
| Hide | Se envía al widget después de que se haya ocultado. |
| Cambio de paleta | Se envía al widget después de que haya cambiado su paleta. |
| FontChange | Se envía al widget después de que haya cambiado su fuente. |
| EnabledChange | Se envía al widget después de que haya cambiado su estado de activación. |
| StyleChange | Se envía al widget después de que haya cambiado su estilo. |
| LayoutDirectionChange | Se envía al widget después de que haya cambiado su dirección de diseño. |
| ContentsRectChange | Se envía al widget después de que hayan cambiado los márgenes o el rectángulo de contenido. |
[override virtual protected] void QGraphicsWidget::focusInEvent(QFocusEvent *event)
Reimplementa: QGraphicsItem::focusInEvent(QFocusEvent *event).
[virtual protected] bool QGraphicsWidget::focusNextPrevChild(bool next)
Busca un nuevo widget al que asignar el foco del teclado, según corresponda para las teclas Tab y Shift+Tab, y devuelve ` true ` si encuentra un nuevo widget; en caso contrario, devuelve ` false `. Si ` next ` es verdadero, esta función busca hacia adelante; si ` next ` es falso, busca hacia atrás.
En ocasiones, es posible que desees reimplementar esta función para proporcionar un manejo especial del foco para tu widget y sus subwidgets. Por ejemplo, un navegador web podría reimplementarla para avanzar o retroceder en el enlace activo actual, y llamar a la implementación base solo cuando llegue al último o al primer enlace de la página.
Los widgets hijos llaman a `focusNextPrevChild()` en sus widgets padres, pero solo la ventana que contiene los widgets hijos decide dónde redirigir el foco. Al reimplementar esta función para un objeto, se obtiene el control del recorrido del foco para todos los widgets hijos.
Véase también ` focusPolicy()`.
[override virtual protected] void QGraphicsWidget::focusOutEvent(QFocusEvent *event)
Reimplementa: QGraphicsItem::focusOutEvent(QFocusEvent *event).
QGraphicsWidget *QGraphicsWidget::focusWidget() const
Si este widget, uno de sus hijos o un descendiente suyo tiene actualmente el foco de entrada, esta función devolverá un puntero a ese widget. Si ningún widget descendiente tiene el foco de entrada, se devuelve nullptr.
Véanse también QGraphicsItem::focusItem() y QWidget::focusWidget().
[signal] void QGraphicsWidget::geometryChanged()
Esta señal se emite cada vez que se modifica la geometría en setGeometry().
[override virtual] void QGraphicsWidget::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
Reimplementa: ` QGraphicsLayoutItem::getContentsMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const`.
Obtiene los márgenes de contenido del widget. Los márgenes se almacenan en ` left`, ` top`, ` right ` y ` bottom`, como punteros a `qreal`. Cada argumento puede omitirse pasando ` nullptr`.
Véase también setContentsMargins().
void QGraphicsWidget::getWindowFrameMargins(qreal *left, qreal *top, qreal *right, qreal *bottom) const
Obtiene los márgenes del marco de la ventana del widget. Los márgenes se almacenan en left, top, right y bottom como punteros a qreals. Cada argumento puede omitirse pasando nullptr.
Véase también setWindowFrameMargins() y windowFrameRect().
[virtual protected] void QGraphicsWidget::grabKeyboardEvent(QEvent *event)
Este controlador de eventos, para event, puede reimplementarse en una subclase para recibir notificaciones de los eventos QEvent::GrabKeyboard.
Véase también grabKeyboard() y grabMouse().
[virtual protected] void QGraphicsWidget::grabMouseEvent(QEvent *event)
Este controlador de eventos, para event, puede reimplementarse en una subclase para recibir notificaciones de los eventos QEvent::GrabMouse.
Véase también grabMouse() y grabKeyboard().
int QGraphicsWidget::grabShortcut(const QKeySequence &sequence, Qt::ShortcutContext context = Qt::WindowShortcut)
Añade un atajo al sistema de atajos de Qt que espera la tecla especificada sequence en el context indicado. Si el context es Qt::ApplicationShortcut, el atajo se aplica a toda la aplicación. De lo contrario, será local para este widget, Qt::WidgetShortcut, o para la propia ventana, Qt::WindowShortcut. En el caso de los widgets que no forman parte de una ventana (es decir, los widgets de nivel superior y sus hijos), Qt::WindowShortcut los atajos se aplican a la escena.
Si varios widgets han capturado la misma tecla sequence, cuando se produce la tecla sequence se envía un evento QEvent::Shortcut a todos los widgets a los que se aplica en un orden no determinista, pero con el indicador «ambiguous» establecido en «true».
Advertencia: Normalmente nodeberías necesitar utilizar esta función; en su lugar, crea « QAction» con las secuencias de teclas de acceso rápido que necesites (si también quieres opciones de menú y botones de barra de herramientas equivalentes), o crea « QShortcut» si solo necesitas secuencias de teclas. Tanto « QAction » como « QShortcut » se encargan de todo el filtrado de eventos por ti y proporcionan señales que se activan cuando el usuario ejecuta la secuencia de teclas, por lo que son mucho más fáciles de usar que esta función de bajo nivel.
Véase también releaseShortcut(), setShortcutEnabled() y QWidget::grabShortcut().
[virtual protected] void QGraphicsWidget::hideEvent(QHideEvent *event)
Este controlador de eventos, para los eventos de « Hide », se activa después de que el widget se haya ocultado; por ejemplo, cuando se ha llamado a «setVisible(false)» para el widget o para uno de sus antepasados, si el widget estaba visible anteriormente.
Puedes reimplementar este controlador de eventos para detectar cuándo se oculta tu widget. Llamar a ` QEvent::accept()` o a ` QEvent::ignore()` sobre ` event ` no tiene ningún efecto.
Véase también showEvent(), QWidget::hideEvent() y ItemVisibleChange.
[override virtual protected] void QGraphicsWidget::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
Reimplementa: ` QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)`.
[override virtual protected] void QGraphicsWidget::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
Reimplementa: ` QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)`.
[virtual protected] void QGraphicsWidget::initStyleOption(QStyleOption *option) const
Rellena un objeto de opciones de estilo para este widget en función de su estado actual y almacena el resultado en ` option`. La implementación por defecto rellena ` option ` con las siguientes propiedades.
| Propiedad de opción de estilo | Valor |
|---|---|
| state & QStyle::State_Enabled | Corresponde a QGraphicsItem::isEnabled(). |
| state & QStyle::State_HasFocus | Corresponde a QGraphicsItem::hasFocus(). |
| estado & QStyle::State_MouseOver | Corresponde a QGraphicsItem::isUnderMouse(). |
| dirección | Corresponde a QGraphicsWidget::layoutDirection(). |
| rect | Equivale a QGraphicsWidget::rect().toRect(). |
| paleta | Equivale a QGraphicsWidget::palette(). |
| fontMetrics | Corresponde a QFontMetrics(QGraphicsWidget::font()). |
Las subclases de ` QGraphicsWidget ` deben llamar a la implementación base y, a continuación, comprobar el tipo de ` option ` utilizando ` qstyleoption_cast<>()` o comprobar ` QStyleOption::Type ` antes de almacenar opciones específicas del widget.
Por ejemplo:
void MyGroupBoxWidget::initStyleOption(QStyleOption *option) const
{
QGraphicsWidget::initStyleOption(option);
if (QStyleOptionGroupBox *box = qstyleoption_cast<QStyleOptionGroupBox *>(option)) {
// Add group box specific state.
box->text = tr("My Group Box");
//...
}
}Véase también ` QStyleOption::initFrom()`.
void QGraphicsWidget::insertAction(QAction *before, QAction *action)
Inserta la acción action en la lista de acciones de este widget, antes de la acción before. Añade la acción al final si before es nullptr o si before no es una acción válida para este widget.
Un ` QGraphicsWidget ` solo debe contener una instancia de cada acción.
Véase también removeAction(), addAction(), QMenu, actions() y QWidget::insertActions().
void QGraphicsWidget::insertActions(QAction *before, const QList<QAction *> &actions)
Inserta las acciones « actions » en la lista de acciones de este widget, antes de la acción « before ». Añade la acción si « before » es « nullptr » o si « before » no es una acción válida para este widget.
Un « QGraphicsWidget » puede tener como máximo una de cada acción.
Véase también removeAction(), QMenu, insertAction() y QWidget::insertActions().
bool QGraphicsWidget::isActiveWindow() const
Devuelve « true » si la ventana de este widget se encuentra en la ventana activa, o si el widget no tiene ventana pero se encuentra en una escena activa (es decir, una escena que tiene el foco en ese momento).
La ventana activa es aquella que contiene un widget hijo que tiene el foco de entrada en ese momento, o aquella que tiene el foco de entrada ella misma.
Véase también QGraphicsScene::activeWindow(), QGraphicsScene::setActiveWindow() y isActive().
[override virtual protected] QVariant QGraphicsWidget::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
Reimplementa: QGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value).
QGraphicsWidget Utiliza la implementación base de esta función para detectar y transmitir eventos relacionados con los cambios de estado del elemento. Por ello, es muy importante que las subclases llamen a la implementación base.
change especifica el tipo de cambio, y value es el nuevo valor.
Por ejemplo, ` QGraphicsWidget ` utiliza `ItemVisibleChange` para enviar los eventos ` Show ` y ` Hide `, `ItemPositionHasChanged` para enviar los eventos ` Move `, y `ItemParentChange` tanto para enviar los eventos ` ParentChange ` como para gestionar la cadena de foco.
QGraphicsWidget Activa el indicador ItemSendsGeometryChanges de forma predeterminada para realizar un seguimiento de los cambios de posición.
Véase también QGraphicsItem::itemChange().
QGraphicsLayout *QGraphicsWidget::layout() const
Devuelve el diseño de este widget o ` nullptr ` si actualmente ningún diseño gestiona este widget.
Nota: Funcióngetter para la propiedad «layout».
Véase también setLayout().
[virtual protected] void QGraphicsWidget::moveEvent(QGraphicsSceneMoveEvent *event)
Este controlador de eventos, para los eventos « GraphicsSceneMove », se activa después de que el widget se haya desplazado (por ejemplo, cuando su posición local ha cambiado).
Este evento solo se emite cuando el elemento se desplaza localmente. Llamar a ` setTransform()` o desplazar cualquiera de los antepasados del elemento no afecta a la posición local del mismo.
Puedes reimplementar este controlador de eventos para detectar cuándo se ha movido tu widget. Llamar a ` QEvent::accept()` o a ` QEvent::ignore()` en ` event ` no tiene ningún efecto.
Véase también ItemPositionChange y ItemPositionHasChanged.
[override virtual] void QGraphicsWidget::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr)
Reimplementa: QGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget).
[virtual] void QGraphicsWidget::paintWindowFrame(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr)
QGraphicsScene llama a esta función virtual para dibujar el marco de las ventanas que utilizan painter, option y widget, en coordenadas locales. La implementación básica utiliza el estilo actual para renderizar el marco y la barra de título.
Puedes reimplementar esta función en una subclase de QGraphicsWidget para proporcionar una representación personalizada del marco de la ventana del widget.
Véase también ` QGraphicsItem::paint()`.
[virtual protected] void QGraphicsWidget::polishEvent()
La escena envía este evento al elemento en algún momento después de que se haya construido, pero antes de que se muestre o se acceda a él de cualquier otra forma a través de la escena. Puedes utilizar este controlador de eventos para realizar inicializaciones de última hora del widget que requieran que el elemento esté completamente construido.
La implementación básica no realiza ninguna acción.
QRectF QGraphicsWidget::rect() const
Devuelve la rectángula local del elemento como un objeto ` QRectF`. Esta función es equivalente a ` QRectF` (QPointF(), ` size()`).
Véase también setGeometry() y resize().
void QGraphicsWidget::releaseShortcut(int id)
Elimina el atajo con el « id » especificado del sistema de atajos de Qt. El widget dejará de recibir eventos « QEvent::Shortcut » para la secuencia de teclas de dicho atajo (a menos que tenga otros atajos con la misma secuencia de teclas).
Advertencia: Normalmente nodeberías necesitar utilizar esta función, ya que el sistema de atajos de Qt elimina los atajos automáticamente cuando se destruye su widget padre. Es mejor utilizar QAction o QShortcut para gestionar los atajos, ya que son más fáciles de usar que esta función de bajo nivel. Ten en cuenta también que se trata de una operación costosa.
Véanse también grabShortcut(), setShortcutEnabled() y QWidget::releaseShortcut().
void QGraphicsWidget::removeAction(QAction *action)
Elimina la acción « action » de la lista de acciones de este widget.
Véase también insertAction(), actions() y QWidget::removeAction().
void QGraphicsWidget::resize(qreal w, qreal h)
Crea un objeto `resize` con los valores de ` width ` (w) y ` height ` (h) proporcionados. Esta función de conveniencia equivale a llamar a `resize(QSizeF(w, h))`.
Nota: Funciónde asignación para la propiedad size.
Se trata de una función sobrecargada.
Véase también setGeometry() y setTransform().
[virtual protected] void QGraphicsWidget::resizeEvent(QGraphicsSceneResizeEvent *event)
Este controlador de eventos, para los eventos « GraphicsSceneResize », se activa después de que se haya redimensionado el widget (es decir, cuando su tamaño local ha cambiado). « event » contiene tanto el tamaño anterior como el nuevo.
Este evento solo se activa cuando el widget cambia de tamaño a nivel local; llamar a ` setTransform()` en el widget, en cualquiera de sus antepasados o en la vista no afecta al tamaño local del widget.
Puedes reimplementar este controlador de eventos para detectar cuándo se ha cambiado el tamaño de tu widget. Llamar a QEvent::accept() o a QEvent::ignore() en event no tiene ningún efecto.
Véase también geometry() y setGeometry().
[override virtual protected] bool QGraphicsWidget::sceneEvent(QEvent *event)
Reimplementa: QGraphicsItem::sceneEvent(QEvent *event).
QGraphicsWidgetLa implementación de `sceneEvent()` simplemente pasa ` event ` a ` QGraphicsWidget::event()`. Puedes gestionar todos los eventos de tu widget en ` event()` o en cualquiera de las funciones de conveniencia; no deberías tener que reimplementar esta función en una subclase de ` QGraphicsWidget`.
Devuelve ` true ` si se ha reconocido y procesado ` event `; en caso contrario, devuelve ` false`.
Véase también QGraphicsItem::sceneEvent().
void QGraphicsWidget::setAttribute(Qt::WidgetAttribute attribute, bool on = true)
Si on es verdadero, esta función habilita attribute; en caso contrario, attribute queda deshabilitado.
Consulta la documentación de la clase ` QGraphicsWidget ` para obtener una lista completa de los atributos compatibles y su finalidad.
Véanse también testAttribute() y QWidget::setAttribute().
void QGraphicsWidget::setContentsMargins(QMarginsF margins)
Establece los márgenes de contenido del widget en « margins ».
Los márgenes de contenido son utilizados por el diseño asignado para definir la ubicación de los subwidgets y los diseños. Los márgenes resultan especialmente útiles para los widgets que limitan los subwidgets a una sección concreta de su propia geometría. Por ejemplo, un cuadro de grupo con un diseño colocará los subwidgets dentro de su marco, pero por debajo del título.
Al modificar los márgenes de contenido de un widget siempre se activará una llamada a ` update()`, y cualquier diseño asignado se activará automáticamente. A continuación, el widget recibirá un evento ` ContentsRectChange `.
Véanse también getContentsMargins() y setGeometry().
void QGraphicsWidget::setContentsMargins(qreal left, qreal top, qreal right, qreal bottom)
Establece los márgenes del contenido del widget en left, top, right y bottom.
Esta es una función sobrecargada.
void QGraphicsWidget::setGeometry(qreal x, qreal y, qreal w, qreal h)
Esta función de conveniencia equivale a llamar a `setGeometry(QRectF( x, y, w, h))`.
Nota: Funciónde configuración para la propiedad geometry.
Véase también geometry() y resize().
void QGraphicsWidget::setLayout(QGraphicsLayout *layout)
Establece el diseño de este widget en « layout ». Cualquier gestor de diseño existente se elimina antes de asignar el nuevo diseño. Si « layout » es « nullptr », el widget queda sin diseño. Las geometrías de los subwidgets existentes no se verán afectadas.
Todos los widgets que actualmente están gestionados por layout o por cualquiera de sus subdiseños pasan automáticamente a estar subordinados a este elemento. A continuación, el diseño se invalida y las geometrías de los widgets hijos se ajustan de acuerdo con los métodos geometry() y contentsMargins() de este elemento. Los hijos que no estén gestionados explícitamente por layout no se ven afectados por el diseño una vez que este se ha asignado a este widget.
QGraphicsWidget Asume la propiedad de layout.
Nota: Funciónde configuración para la propiedad layout.
Véase también layout(), QGraphicsLinearLayout::addItem() y QGraphicsLayout::invalidate().
void QGraphicsWidget::setShortcutAutoRepeat(int id, bool enabled = true)
Si enabled es verdadero, se activa la repetición automática del atajo con el id especificado; en caso contrario, se desactiva.
Véase también grabShortcut(), releaseShortcut() y QWidget::setShortcutAutoRepeat().
void QGraphicsWidget::setShortcutEnabled(int id, bool enabled = true)
Si « enabled » es «true», se activa el atajo con la « id » indicada; en caso contrario, el atajo queda desactivado.
Advertencia: Normalmente nodebería ser necesario utilizar esta función, ya que el sistema de atajos de Qt activa o desactiva los atajos automáticamente a medida que los widgets se ocultan o se muestran y ganan o pierden el foco. Es mejor utilizar QAction o QShortcut para gestionar los atajos, ya que son más fáciles de usar que esta función de bajo nivel.
Véase también grabShortcut(), releaseShortcut() y QWidget::setShortcutEnabled().
void QGraphicsWidget::setStyle(QStyle *style)
Establece el estilo del widget en « style ». « QGraphicsWidget » no asume la propiedad de « style ».
Si no se asigna ningún estilo, o si style es nullptr, el widget utilizará QGraphicsScene::style() (si se ha configurado). En caso contrario, el widget utilizará QApplication::style().
Esta función establece el atributo Qt::WA_SetStyle si style no es nullptr; en caso contrario, borra el atributo.
Véase también style().
[static] void QGraphicsWidget::setTabOrder(QGraphicsWidget *first, QGraphicsWidget *second)
Mueve el widget « second » por el anillo de widgets de enfoque, de modo que el foco del teclado pase del widget « first » al widget « second » al pulsar la tecla Tab.
Ten en cuenta que, dado que se modifica el orden de tabulación del widget second, debes ordenar la cadena de la siguiente manera:
setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to dyno así:
// WRONG
setTabOrder(c, d); // c to d
setTabOrder(a, b); // a to b AND c to d
setTabOrder(b, c); // a to b to c, but not c to dSi first es nullptr, esto indica que second debe ser el primer widget en recibir el foco de entrada en caso de que la escena obtenga el foco de Tab (es decir, cuando el usuario pulsa Tab para que el foco pase a la escena). Si second es nullptr, esto indica que first debe ser el primer widget en obtener el foco si la escena obtiene el foco de BackTab.
Por defecto, el orden de tabulación se define implícitamente según el orden de creación de los widgets.
Véase también « focusPolicy » y «Foco del teclado en los widgets».
void QGraphicsWidget::setWindowFrameMargins(QMarginsF margins)
Establece los márgenes del marco de la ventana del widget en margins. Los márgenes predeterminados del marco vienen determinados por el estilo y dependen de los indicadores actuales de la ventana.
Si deseas dibujar tu propia decoración de ventana, puedes establecer tus propios márgenes del marco para anular los márgenes predeterminados.
Véase también unsetWindowFrameMargins(), getWindowFrameMargins() y windowFrameRect().
void QGraphicsWidget::setWindowFrameMargins(qreal left, qreal top, qreal right, qreal bottom)
Establece los márgenes del marco de la ventana del widget en left, top, right y bottom.
Esta es una función sobrecargada.
[override virtual] QPainterPath QGraphicsWidget::shape() const
Reimplementa: ` QGraphicsItem::shape()` const.
[virtual protected] void QGraphicsWidget::showEvent(QShowEvent *event)
Este controlador de eventos, para los eventos « Show », se activa antes de que se muestre el widget; por ejemplo, cuando se ha llamado a «setVisible(true)» para el widget o para uno de sus antepasados, si el widget estaba oculto anteriormente.
Puedes reimplementar este controlador de eventos para detectar cuándo se muestra tu widget. Llamar a ` QEvent::accept()` o ` QEvent::ignore()` en ` event ` no tiene ningún efecto.
Véase también hideEvent(), QWidget::showEvent() y ItemVisibleChange.
[override virtual protected] QSizeF QGraphicsWidget::sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const
Reimplementa: ` QGraphicsLayoutItem::sizeHint` (`Qt::SizeHint which, const QSizeF &constraint) const`.
QStyle *QGraphicsWidget::style() const
Devuelve un puntero al estilo del widget. Si este widget no tiene ningún estilo asignado explícitamente, se devuelve en su lugar el estilo de la escena. A su vez, si la escena no tiene ningún estilo asignado, esta función devuelve QApplication::style().
Véase también setStyle().
bool QGraphicsWidget::testAttribute(Qt::WidgetAttribute attribute) const
Devuelve « true » si la opción « attribute » está habilitada para este widget; en caso contrario, devuelve « false ».
Véase también setAttribute().
[override virtual] int QGraphicsWidget::type() const
Reimplementa: QGraphicsItem::type() const.
[virtual protected] void QGraphicsWidget::ungrabKeyboardEvent(QEvent *event)
Este controlador de eventos, para event, puede reimplementarse en una subclase para recibir notificaciones de eventos de QEvent::UngrabKeyboard.
Véase también ungrabKeyboard() y ungrabMouse().
[virtual protected] void QGraphicsWidget::ungrabMouseEvent(QEvent *event)
Este controlador de eventos, para event, puede reimplementarse en una subclase para recibir notificaciones de los eventos QEvent::UngrabMouse.
Véanse también ungrabMouse() y ungrabKeyboard().
void QGraphicsWidget::unsetWindowFrameMargins()
Restablece los márgenes del marco de la ventana al valor por defecto, según lo establecido por el estilo.
Véase también setWindowFrameMargins(), getWindowFrameMargins() y windowFrameRect().
[override virtual protected] void QGraphicsWidget::updateGeometry()
Reimplementa: QGraphicsLayoutItem::updateGeometry().
Si este widget está gestionado actualmente por un diseño, esta función notifica al diseño que las indicaciones de tamaño del widget han cambiado y que es posible que el diseño tenga que redimensionar y reposicionar el widget en consecuencia.
Llama a esta función si el método sizeHint() del widget ha cambiado.
Véase también QGraphicsLayout::invalidate().
[virtual protected] bool QGraphicsWidget::windowFrameEvent(QEvent *event)
Este controlador de eventos, para ` event`, recibe eventos relacionados con el marco de la ventana si este widget es una ventana. Su implementación base ofrece soporte para la interacción predeterminada con el marco de la ventana, como el desplazamiento, el cambio de tamaño, etc.
Puedes reimplementar este controlador en una subclase de ` QGraphicsWidget ` para proporcionar tu propio soporte personalizado para la interacción con el marco de la ventana.
Devuelve ` true ` si se ha reconocido y procesado un ` event `; en caso contrario, devuelve ` false`.
Véase también event().
QRectF QGraphicsWidget::windowFrameGeometry() const
Devuelve la geometría del widget en coordenadas del elemento padre, incluyendo cualquier marco de ventana.
Véase también windowFrameRect(), getWindowFrameMargins() y setWindowFrameMargins().
QRectF QGraphicsWidget::windowFrameRect() const
Devuelve el rect local del widget, incluyendo cualquier marco de ventana.
Véase también windowFrameGeometry(), getWindowFrameMargins() y setWindowFrameMargins().
[virtual protected] Qt::WindowFrameSection QGraphicsWidget::windowFrameSectionAt(const QPointF &pos) const
Devuelve la sección del marco de la ventana situada en la posición pos, o Qt::NoSection si no hay ninguna sección del marco de la ventana en esa posición.
Esta función se utiliza en la implementación básica de ` QGraphicsWidget` para la interacción con el marco de la ventana.
Puedes reimplementar esta función si deseas personalizar la forma en que se puede mover o redimensionar una ventana de forma interactiva. Por ejemplo, si solo quieres permitir que se redimensione una ventana desde la esquina inferior derecha, puedes reimplementar esta función para que devuelva Qt::NoSection para todas las secciones excepto Qt::BottomRightSection.
Véanse también windowFrameEvent(), paintWindowFrame() y windowFrameGeometry().
Qt::WindowType QGraphicsWidget::windowType() const
Devuelve el tipo de ventana de los widgets.
Véase también windowFlags(), isWindow() y isPanel().
© 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.