QWidget Class

Documentación de las funciones miembro

[explicit] QWidget::QWidget(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())

Construye un widget que es hijo de parent, con las banderas de widget establecidas en f.

Si parent es nullptr, el nuevo widget se convierte en una ventana. Si parent es otro widget, este widget se convierte en una ventana hija dentro de parent. El nuevo widget se elimina cuando se elimina su parent.

El argumento de las banderas del widget, f, es normalmente 0, pero puede establecerse para personalizar el marco de una ventana (es decir, parent debe ser nullptr). Para personalizar el marco, utilice un valor compuesto a partir del OR bitwise de cualquiera de los window flags.

Si añades un widget hijo a un widget ya visible, debes mostrar explícitamente el hijo para hacerlo visible.

Tenga en cuenta que la versión X11 de Qt puede no ser capaz de ofrecer todas las combinaciones de banderas de estilo en todos los sistemas. Esto se debe a que en X11, Qt sólo puede preguntar al gestor de ventanas, y el gestor de ventanas puede anular la configuración de la aplicación. En Windows, Qt puede establecer cualquier bandera que desee.

Véase también windowFlags.

[virtual noexcept] QWidget::~QWidget()

Destruye el widget.

Todos los hijos de este widget se borran primero. La aplicación se cierra si este widget es el widget principal.

[virtual protected] void QWidget::actionEvent(QActionEvent *event)

Este manejador de eventos es llamado con el event dado cada vez que se cambian las acciones del widget.

Véase también addAction(), insertAction(), removeAction(), actions(), y QActionEvent.

QList<QAction *> QWidget::actions() const

Devuelve la lista (posiblemente vacía) de las acciones de este widget.

Véase también contextMenuPolicy, insertAction(), y removeAction().

void QWidget::activateWindow()

Establece el widget de nivel superior que contiene este widget como ventana activa.

Una ventana activa es una ventana visible de nivel superior que tiene el foco de entrada del teclado.

Esta función realiza la misma operación que hacer clic con el ratón en la barra de título de una ventana de nivel superior. En X11, el resultado depende del gestor de ventanas. Si desea asegurarse de que la ventana también se apila en la parte superior, también debe llamar a raise(). Tenga en cuenta que la ventana debe ser visible, de lo contrario activateWindow() no tiene ningún efecto.

En Windows, si llama a esta función cuando la aplicación no es actualmente la activa, entonces no la convertirá en la ventana activa. Cambiará el color de la entrada de la barra de tareas para indicar que la ventana ha cambiado de alguna manera. Esto se debe a que Microsoft no permite que una aplicación interrumpa lo que el usuario está haciendo actualmente en otra aplicación.

Véase también isActiveWindow(), window(), y show().

void QWidget::addAction(QAction *action)

Añade la acción action a la lista de acciones de este widget.

Todos los QWidgets tienen una lista de QActions. Sin embargo, pueden representarse gráficamente de muchas maneras diferentes. El uso por defecto de la lista QAction (devuelta por actions()) es crear un contexto QMenu.

Un QWidget sólo debe tener una de cada acción y añadir una acción que ya tenga no hará que la misma acción esté dos veces en el widget.

La propiedad de action no se transfiere a este QWidget.

Véase también removeAction(), insertAction(), actions(), y QMenu.

Estas funciones crean una nueva acción con el texto text, el icono icon y el acceso directo shortcut, si lo hay.

Las funciones añaden la acción recién creada a la lista de acciones del widget y la devuelven.

QWidget toma posesión de la acción devuelta QAction.

Estas funciones se introdujeron en Qt 6.3.

Estas funciones de conveniencia crean una nueva acción con el texto text, el icono icon, y el acceso directo shortcut, si existe.

La señal triggered() de la acción se conecta como si fuera una llamada a QObject::connect(action, &QAction::triggered, args...), reenviando perfectamente args, incluyendo un posible Qt::ConnectionType.

La función añade la acción recién creada a la lista de acciones del widget y la devuelve.

QWidget toma posesión de la acción devuelta QAction.

Estas funciones se introdujeron en Qt 6.3.

Esta función crea una nueva acción con el texto text, el icono icon, y el atajo shortcut, si existe.

La señal triggered() de la acción se conecta a la ranura receiver's member. La función añade la acción recién creada a la lista de acciones del widget y la devuelve.

QWidget toma posesión de la acción devuelta QAction.

Estas funciones se introdujeron en Qt 6.3.

void QWidget::addActions(const QList<QAction *> &actions)

Añade las acciones actions a la lista de acciones de este widget.

Véase también removeAction(), QMenu, y addAction().

void QWidget::adjustSize()

Ajusta el tamaño del widget para que se ajuste a su contenido.

Esta función utiliza sizeHint() si es válido, es decir, si la anchura y la altura de la sugerencia de tamaño son >= 0. En caso contrario, ajusta el tamaño al rectángulo hijo que abarca todos los widgets hijos (la unión de todos los rectángulos de widgets hijos).

En el caso de las ventanas, también se tiene en cuenta el tamaño de la pantalla. Si sizeHint() es menor que (200, 100) y la política de tamaño es expanding, la ventana tendrá un tamaño mínimo de (200, 100). El tamaño máximo de una ventana es 2/3 de la anchura y la altura de la pantalla.

Véase también sizeHint() y childrenRect().

QPalette::ColorRole QWidget::backgroundRole() const

Devuelve el rol de fondo del widget.

El rol de fondo define el pincel de palette del widget que se utiliza para representar el fondo.

Si no se establece un rol de fondo explícito, el widget hereda el rol de fondo de su widget padre.

Véase también setBackgroundRole() y foregroundRole().

QBackingStore *QWidget::backingStore() const

Devuelve el QBackingStore en el que se dibujará este widget.

[virtual protected] void QWidget::changeEvent(QEvent *event)

Este manejador de eventos puede ser reimplementado para manejar cambios de estado.

El estado que se cambia en este evento se puede recuperar a través de la event suministrada.

Los eventos de cambio incluyen: QEvent::ToolBarChange, QEvent::ActivationChange, QEvent::EnabledChange, QEvent::FontChange, QEvent::StyleChange, QEvent::PaletteChange, QEvent::WindowTitleChange, QEvent::IconTextChange, QEvent::ModifiedChange, QEvent::MouseTrackingChange, QEvent::ParentChange, QEvent::WindowStateChange, QEvent::LanguageChange, QEvent::LocaleChange, QEvent::LayoutDirectionChange, QEvent::ReadOnlyChange.

QWidget *QWidget::childAt(int x, int y) const

Devuelve el widget hijo visible en la posición (x, y) en el sistema de coordenadas del widget. Si no hay ningún widget hijo visible en la posición especificada, la función devuelve nullptr.

QWidget *QWidget::childAt(const QPoint &p) const

Devuelve el widget hijo visible en el punto p en el sistema de coordenadas del propio widget.

[since 6.8] QWidget *QWidget::childAt(const QPointF &p) const

Devuelve el widget hijo visible en el punto p en el sistema de coordenadas del propio widget.

Esta función se introdujo en Qt 6.8.

void QWidget::clearFocus()

Toma el foco de entrada de teclado del widget.

Si el widget tiene el foco activo, se envía un focus out event a este widget para decirle que ha perdido el foco.

Este widget debe activar el foco para obtener el foco de entrada del teclado; es decir, debe llamar a setFocusPolicy().

Véase también hasFocus(), setFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), y QApplication::focusWidget().

void QWidget::clearMask()

Elimina cualquier máscara establecida por setMask().

Véase también setMask().

[slot] bool QWidget::close()

Cierra este widget. Devuelve true si el widget fue cerrado; en caso contrario devuelve false.

Primero envía al widget un QCloseEvent. El widget es hidden si accepts el evento de cierre. Si ignores el evento, no ocurre nada. La implementación por defecto de QWidget::closeEvent() acepta el evento de cierre.

Si el widget tiene la bandera Qt::WA_DeleteOnClose, el widget también es eliminado. Un evento de cierre es enviado al widget sin importar si el widget es visible o no.

La señal QGuiApplication::lastWindowClosed() se emite cuando se cierra la última ventana primaria visible (es decir, la ventana sin padre) con el atributo Qt::WA_QuitOnClose establecido. Por defecto, este atributo está establecido para todos los widgets excepto para las ventanas transitorias, como las pantallas de inicio, las ventanas de herramientas y los menús emergentes.

[virtual protected] void QWidget::closeEvent(QCloseEvent *event)

Este manejador de eventos es llamado con el event dado cuando Qt recibe una petición de cierre de ventana para un widget de nivel superior desde el sistema de ventanas.

Por defecto, el evento es aceptado y el widget se cierra. Puedes reimplementar esta función para cambiar la forma en que el widget responde a las peticiones de cierre de ventana. Por ejemplo, puedes evitar que la ventana se cierre llamando a ignore() en todos los eventos.

Las aplicaciones de ventana principal suelen utilizar reimplementaciones de esta función para comprobar si se ha guardado el trabajo del usuario y pedir permiso antes de cerrar.

Véase también event(), hide(), close(), y QCloseEvent.

QMargins QWidget::contentsMargins() const

La función contentsMargins devuelve los márgenes de contenido del widget.

Véase también setContentsMargins() y contentsRect().

QRect QWidget::contentsRect() const

Devuelve el área dentro de los márgenes del widget.

Véase también setContentsMargins() y contentsMargins().

[virtual protected] void QWidget::contextMenuEvent(QContextMenuEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos del menú contextual del widget.

El manejador es llamado cuando el widget contextMenuPolicy es Qt::DefaultContextMenu.

La implementación por defecto ignora el evento de contexto. Consulta la documentación de QContextMenuEvent para más detalles.

Véase también event(), QContextMenuEvent, y customContextMenuRequested().

[protected] void QWidget::create(WId window = 0, bool initializeWindow = true, bool destroyOldWindow = true)

Crea una nueva ventana de widget.

Los parámetros window, initializeWindow, y destroyOldWindow son ignorados en Qt 5. Por favor, utilice QWindow::fromWinId() para crear un QWindow envolviendo una ventana ajena y páselo a QWidget::createWindowContainer() en su lugar.

Véase también createWindowContainer() y QWindow::fromWinId().

[static] QWidget *QWidget::createWindowContainer(QWindow *window, QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags())

Crea un QWidget que permite incrustar window en una aplicación basada en QWidget.

El contenedor de ventanas se crea como hijo de parent y con los indicadores de ventana flags.

Una vez incrustada la ventana en el contenedor, éste controlará la geometría y visibilidad de la ventana. No se recomienda realizar llamadas explícitas a QWindow::setGeometry(), QWindow::show() o QWindow::hide() en una ventana incrustada.

El contenedor asume la propiedad de window. La ventana puede eliminarse del contenedor de ventanas con una llamada a QWindow::setParent().

El contenedor de ventanas se adjunta como ventana hija nativa a la ventana de nivel superior de la que es hija. Cuando un contenedor de ventanas se utiliza como hijo de QAbstractScrollArea o QMdiArea, creará un native window para cada widget de su cadena padre para permitir el apilamiento y recorte adecuados en este caso de uso. La creación de una ventana nativa para el contenedor de ventanas también permite un apilamiento y recorte adecuados. Esto debe hacerse antes de mostrar la ventana contenedora. Las aplicaciones con muchas ventanas hijas nativas pueden sufrir problemas de rendimiento.

El contenedor de ventanas tiene una serie de limitaciones conocidas:

• Orden de apilamiento; La ventana incrustada se apilará encima de la jerarquía de widgets como una caja opaca. El orden de apilamiento de varias ventanas contenedoras superpuestas no está definido.
• Integración de renderizado; El contenedor de ventanas no interopera con QGraphicsProxyWidget, QWidget::render() o funcionalidades similares.
• Manejo del foco; Es posible dejar que la instancia de contenedor de ventana tenga cualquier política de foco y delegará el foco a la ventana a través de una llamada a QWindow::requestActivate(). Sin embargo, volver a la cadena de enfoque normal desde la instancia QWindow dependerá de la propia implementación de la instancia QWindow. También, si QWindow::requestActivate() realmente da el foco a la ventana, depende de la plataforma.

  Desde la versión 6.8, si se incrusta una ventana basada en Qt Quick, al pulsar el tabulador se realiza una transición dentro y fuera de la ventana QML incrustada, permitiendo que el foco se mueva al objeto enfocable siguiente o anterior en la cadena contenedora de la ventana.

• El uso de muchas instancias de contenedores de ventanas en una aplicación basada en QWidget puede perjudicar enormemente el rendimiento general de la aplicación.
• Desde la versión 6.7, si window pertenece a un widget (es decir, window se recibió al llamar a windowHandle()), no se creará ningún contenedor. En su lugar, esta función devolverá el propio widget, después de ser reparentado a parent. Dado que no se creará ningún contenedor, flags será ignorado. En otras palabras, si window pertenece a un widget, considera simplemente reparenting ese widget a parent en lugar de utilizar esta función.

[signal] void QWidget::customContextMenuRequested(const QPoint &pos)

Esta señal se emite cuando la contextMenuPolicy del widget es Qt::CustomContextMenu, y el usuario ha solicitado un menú contextual en el widget. La posición pos es la posición del evento de menú contextual que recibe el widget. Normalmente está en coordenadas del widget. La excepción a esta regla es QAbstractScrollArea y sus subclases que mapean el evento de menú contextual a coordenadas del viewport().

Véase también mapToGlobal(), QMenu, y contextMenuPolicy.

[protected] void QWidget::destroy(bool destroyWindow = true, bool destroySubWindows = true)

Libera recursos del sistema de ventanas. Destruye la ventana del widget si destroyWindow es verdadero.

destroy() se llama a sí misma recursivamente para todos los widgets hijos, pasando destroySubWindows como parámetro destroyWindow. Para tener más control sobre la destrucción de los subwidgets, destruya primero los subwidgets de forma selectiva.

Esta función se llama normalmente desde el destructor QWidget.

[virtual protected] void QWidget::dragEnterEvent(QDragEnterEvent *event)

Este manejador de eventos es llamado cuando un arrastre está en progreso y el ratón entra en este widget. El evento se pasa en el parámetro event.

Si el evento es ignorado, el widget no recibirá ningún drag move events.

Consulta la documentación Arrastrar y soltar para obtener una visión general de cómo proporcionar la función arrastrar y soltar en tu aplicación.

Véase también QDrag y QDragEnterEvent.

[virtual protected] void QWidget::dragLeaveEvent(QDragLeaveEvent *event)

Este manejador de eventos es llamado cuando un arrastre está en progreso y el ratón abandona este widget. El evento se pasa en el parámetro event.

Consulta la documentación Arrastrar y soltar para obtener una visión general de cómo proporcionar la función arrastrar y soltar en tu aplicación.

Véase también QDrag y QDragLeaveEvent.

[virtual protected] void QWidget::dragMoveEvent(QDragMoveEvent *event)

Este manejador de eventos es llamado si un arrastre está en progreso, y cuando cualquiera de las siguientes condiciones ocurren: el cursor entra en este widget, el cursor se mueve dentro de este widget, o una tecla modificadora es presionada en el teclado mientras este widget tiene el foco. El evento se pasa en el parámetro event.

Consulta la documentación Arrastrar y soltar para obtener una visión general de cómo proporcionar la función arrastrar y soltar en tu aplicación.

Véase también QDrag y QDragMoveEvent.

[virtual protected] void QWidget::dropEvent(QDropEvent *event)

Este manejador de eventos es llamado cuando el arrastre es soltado en este widget. El evento se pasa en el parámetro event.

Consulta la documentación de arrastrar y soltar para obtener una visión general de cómo proporcionar arrastrar y soltar en tu aplicación.

Ver también QDrag y QDropEvent.

WId QWidget::effectiveWinId() const

Devuelve el identificador efectivo del sistema de ventanas del widget, es decir, el identificador del sistema de ventanas del padre nativo.

Si el widget es nativo, esta función devuelve el identificador del widget nativo. En caso contrario, devuelve el identificador de ventana del primer widget padre nativo, es decir, el widget de nivel superior que contiene este widget.

Véase también nativeParentWidget().

void QWidget::ensurePolished() const

Asegura que el widget y sus hijos han sido pulidos por QStyle (es decir, tienen una fuente y paleta adecuadas).

QWidget llama a esta función después de que se haya construido completamente pero antes de que se muestre por primera vez. Puedes llamar a esta función si quieres asegurarte de que el widget está pulido antes de realizar una operación, por ejemplo, el tamaño de fuente correcto podría ser necesario en la reimplementación de sizeHint() del widget. Tenga en cuenta que esta función se llama desde la implementación por defecto de sizeHint().

El pulido es útil para la inicialización final que debe ocurrir después de que todos los constructores (tanto de clases base como de subclases) hayan sido llamados.

Si necesitas cambiar algunos ajustes cuando un widget es pulido, reimplementa event() y maneja el tipo de evento QEvent::Polish.

Nota: La función se declara const para que pueda ser llamada desde otras funciones const (por ejemplo, sizeHint()).

Véase también event().

[virtual protected] void QWidget::enterEvent(QEnterEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de entrada al widget que son pasados en el parámetro event.

Se envía un evento al widget cuando el cursor del ratón entra en el widget.

Ver también leaveEvent(), mouseMoveEvent(), y event().

[override virtual protected] bool QWidget::event(QEvent *event)

Reimplementa: QObject::event(QEvent *e).

Este es el manejador de eventos principal; maneja el evento event. Puede reimplementar esta función en una subclase, pero recomendamos usar uno de los manejadores de eventos especializados en su lugar.

Los eventos de pulsación y liberación de teclas se tratan de forma diferente a otros eventos. event() comprueba si hay Tabulador y Mayús+Tabulador e intenta mover el foco apropiadamente. Si no hay widget al que mover el foco (o la tecla pulsada no es Tab o Shift+Tab), event() llama a keyPressEvent().

El manejo de eventos de ratón y tableta es también ligeramente especial: sólo cuando el widget es enabled, event() llamará a los manejadores especializados como mousePressEvent(); en caso contrario descartará el evento.

Esta función devuelve true si el evento fue reconocido, en caso contrario devuelve false. Si el evento reconocido fue aceptado (ver QEvent::accepted), cualquier procesamiento posterior como la propagación del evento al widget padre se detiene.

Véase también closeEvent(), focusInEvent(), focusOutEvent(), enterEvent(), keyPressEvent(), keyReleaseEvent(), leaveEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), mousePressEvent(), mouseReleaseEvent(), moveEvent(), paintEvent(), resizeEvent(), QObject::event(), y QObject::timerEvent().

[static] QWidget *QWidget::find(WId id)

Devuelve un puntero al widget con identificador/manejador de ventana id.

El tipo de identificador de ventana depende del sistema de ventanas subyacente, véase qwindowdefs.h para la definición real. Si no hay ningún widget con este identificador, se devuelve nullptr.

[virtual protected] void QWidget::focusInEvent(QFocusEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de foco de teclado (foco recibido) para el widget. El evento se pasa en el parámetro event

Un widget normalmente debe setFocusPolicy() a algo distinto de Qt::NoFocus para recibir eventos de foco. (Ten en cuenta que el programador de la aplicación puede llamar a setFocus() en cualquier widget, incluso en aquellos que normalmente no aceptan el foco).

La implementación por defecto actualiza el widget (excepto para las ventanas que no especifican un focusPolicy()).

Véase también focusOutEvent(), setFocusPolicy(), keyPressEvent(), keyReleaseEvent(), event(), y QFocusEvent.

[protected] bool QWidget::focusNextChild()

Busca un nuevo widget al que dar el foco del teclado, según sea apropiado para Tab, y devuelve true si puede encontrar un nuevo widget, o false si no puede.

Véase también focusPreviousChild().

[virtual protected] bool QWidget::focusNextPrevChild(bool next)

Busca un nuevo widget al que dar el foco del teclado, según sea apropiado para Tab y Shift+Tab, y devuelve true si puede encontrar un nuevo widget, o false si no puede.

Si next es verdadero, esta función busca hacia adelante, si next es falso, busca hacia atrás.

A veces, querrás reimplementar esta función. Por ejemplo, un navegador web podría reimplementarla para mover su "enlace activo actual" hacia adelante o hacia atrás, y llamar a focusNextPrevChild() sólo cuando alcanza el último o el primer enlace de la "página".

Los widgets hijos llaman a focusNextPrevChild() en sus widgets padres, pero sólo la ventana que contiene los widgets hijos decide a dónde redirigir el foco. Al reimplementar esta función para un objeto, se obtiene el control del desplazamiento del foco para todos los widgets hijos.

Véase también focusNextChild() y focusPreviousChild().

[virtual protected] void QWidget::focusOutEvent(QFocusEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de foco de teclado (foco perdido) para el widget. Los eventos se pasan en el parámetro event.

Un widget normalmente debe setFocusPolicy() a algo distinto de Qt::NoFocus para recibir eventos de foco. (Ten en cuenta que el programador de la aplicación puede llamar a setFocus() en cualquier widget, incluso en aquellos que normalmente no aceptan el foco).

La implementación por defecto actualiza el widget (excepto para las ventanas que no especifican un focusPolicy()).

Véase también focusInEvent(), setFocusPolicy(), keyPressEvent(), keyReleaseEvent(), event(), y QFocusEvent.

[protected] bool QWidget::focusPreviousChild()

Busca un nuevo widget al que dar el foco del teclado, según sea apropiado para Shift+Tab, y devuelve true si puede encontrar un nuevo widget, o false si no puede.

Véase también focusNextChild().

QWidget *QWidget::focusProxy() const

Devuelve el proxy de enfoque, o nullptr si no hay proxy de enfoque.

Véase también setFocusProxy().

QWidget *QWidget::focusWidget() const

Devuelve el último hijo de este widget sobre el que se ha llamado a setFocus. Para los widgets de nivel superior, este es el widget que obtendrá el foco en caso de que esta ventana se active.

Esto no es lo mismo que QApplication::focusWidget(), que devuelve el widget enfocado en la ventana actualmente activa.

QFontInfo QWidget::fontInfo() const

Devuelve la información de la fuente actual del widget. Equivale a QFontInfo(widget->font()).

Véase también font(), fontMetrics() y setFont().

QFontMetrics QWidget::fontMetrics() const

Devuelve las métricas de la fuente actual del widget. Equivale a QFontMetrics(widget->font()).

Véase también font(), fontInfo() y setFont().

QPalette::ColorRole QWidget::foregroundRole() const

Devuelve el rol de primer plano.

El rol de primer plano define el color de palette del widget que se utiliza para dibujar el primer plano.

Si no se establece explícitamente un rol de primer plano, la función devuelve un rol que contrasta con el rol de fondo.

Véase también setForegroundRole() y backgroundRole().

[invokable] QPixmap QWidget::grab(const QRect &rectangle = QRect(QPoint(0, 0), QSize(-1, -1)))

Renderiza el widget en un mapa de píxeles restringido por la dirección rectangle. Si el widget tiene hijos, también se pintan en las posiciones apropiadas.

Si se especifica un rectángulo con un tamaño no válido (por defecto), se pintará todo el widget.

Véase también render() y QPixmap.

void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags = Qt::GestureFlags())

Suscribe el widget a un determinado gesture con flags específico.

Véase también ungrabGesture() y QGestureEvent.

void QWidget::grabKeyboard()

Toma la entrada del teclado.

Este widget recibe todos los eventos de teclado hasta que se llama a releaseKeyboard(); otros widgets no reciben ningún evento de teclado. Los eventos de ratón no se ven afectados. Usa grabMouse() si quieres cogerlos.

El widget de foco no se ve afectado, excepto que no recibe ningún evento de teclado. setFocus() mueve el foco como de costumbre, pero el nuevo widget de foco recibe eventos de teclado sólo después de llamar a releaseKeyboard().

Si un widget diferente está capturando la entrada del teclado, la captura de ese widget se libera primero.

Véase también releaseKeyboard(), grabMouse(), releaseMouse(), y focusWidget().

void QWidget::grabMouse()

Toma la entrada del ratón.

Este widget recibe todos los eventos de ratón hasta que se llama a releaseMouse(); otros widgets no reciben ningún evento de ratón. Los eventos de teclado no se ven afectados. Usa grabKeyboard() si quieres tomarlos.

Rara vez es necesario agarrar el ratón cuando se usa Qt, ya que Qt lo agarra y lo suelta con sensatez. En particular, Qt agarra el ratón cuando se pulsa un botón del ratón y lo mantiene hasta que se suelta el último botón.

Véase también releaseMouse(), grabKeyboard(), y releaseKeyboard().

void QWidget::grabMouse(const QCursor &cursor)

Toma la entrada del ratón y cambia la forma del cursor.

El cursor asumirá la forma cursor (mientras se mantenga el foco del ratón) y este widget será el único que reciba eventos del ratón hasta que se llame a releaseMouse()().

Ver también releaseMouse(), grabKeyboard(), releaseKeyboard(), y setCursor().

int QWidget::grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut)

Añade un acceso directo al sistema de accesos directos de Qt que busca la secuencia key dada en el context dado. Si context es Qt::ApplicationShortcut, el acceso directo se aplica a toda la aplicación. De lo contrario, es local a este widget, Qt::WidgetShortcut, o a la propia ventana, Qt::WindowShortcut.

Si la misma secuencia key ha sido capturada por varios widgets, cuando se produce la secuencia key se envía un evento QEvent::Shortcut a todos los widgets a los que se aplica en un orden no determinista, pero con la bandera ``ambigua'' puesta a true.

Véase también releaseShortcut() y setShortcutEnabled().

QGraphicsEffect *QWidget::graphicsEffect() const

La función graphicsEffect devuelve un puntero al efecto gráfico del widget.

Si el widget no tiene efecto gráfico, se devuelve nullptr.

Véase también setGraphicsEffect().

QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const

Devuelve el widget proxy para el widget incrustado correspondiente en una vista gráfica; en caso contrario devuelve nullptr.

Véase también QGraphicsProxyWidget::createProxyForChildWidget() y QGraphicsScene::addWidget().

bool QWidget::hasEditFocus() const

Devuelve true si este widget tiene actualmente el foco de edición; en caso contrario, false.

Esta función sólo está disponible en Qt for Embedded Linux.

Véase también setEditFocus() y QApplication::navigationMode().

[virtual] bool QWidget::hasHeightForWidth() const

Devuelve true si la altura preferida del widget depende de su anchura; en caso contrario devuelve false.

[virtual] int QWidget::heightForWidth(int w) const

Devuelve la altura preferida para este widget, dada la anchura w.

Si este widget tiene un diseño, la implementación por defecto devuelve la altura preferida del diseño. Si no hay diseño, la implementación por defecto devuelve -1 indicando que la altura preferida no depende de la anchura.

[slot] void QWidget::hide()

Oculta el widget. Esta función es equivalente a setVisible(false).

Véase también hideEvent(), isHidden(), show(), setVisible(), isVisible() y close().

[virtual protected] void QWidget::hideEvent(QHideEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de ocultación de widgets. El evento se pasa en el parámetro event.

Los eventos de ocultación se envían a los widgets inmediatamente después de que hayan sido ocultados.

Nota: Un widget recibe eventos espontáneos de mostrar y ocultar cuando su estado de asignación es cambiado por el sistema de ventanas, por ejemplo, un evento espontáneo de ocultar cuando el usuario minimiza la ventana, y un evento espontáneo de mostrar cuando la ventana es restaurada de nuevo. Tras recibir un evento de ocultación espontánea, un widget sigue considerándose visible en el sentido de isVisible().

Véase también visible, event(), y QHideEvent.

[override virtual protected] void QWidget::initPainter(QPainter *painter) const

Inicializa la pluma, el fondo y la fuente de painter a los mismos que los del widget dado. Esta función se ejecuta automáticamente cuando se abre el pintor en QWidget.

[virtual protected] void QWidget::inputMethodEvent(QInputMethodEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de composición del Método de Entrada. Este manejador es llamado cuando el estado del método de entrada cambia.

Tenga en cuenta que al crear widgets de edición de texto personalizados, el atributo de ventana Qt::WA_InputMethodEnabled debe establecerse explícitamente (utilizando la función setAttribute()) para poder recibir eventos de método de entrada.

La implementación por defecto llama a event->ignore(), que rechaza el evento Input Method. Consulte la documentación de QInputMethodEvent para más detalles.

Véase también event() y QInputMethodEvent.

[virtual] QVariant QWidget::inputMethodQuery(Qt::InputMethodQuery query) const

Este método sólo es relevante para los widgets de entrada. Es utilizado por el método de entrada para consultar un conjunto de propiedades del widget para poder soportar operaciones complejas del método de entrada como soporte para texto circundante y reconversiones.

query especifica qué propiedad se consulta.

Véase también inputMethodEvent(), QInputMethodEvent, QInputMethodQueryEvent, y inputMethodHints.

void QWidget::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 si before es nullptr o before no es una acción válida para este widget.

Un QWidget sólo debe tener una de cada acción.

Véase también removeAction(), addAction(), QMenu, contextMenuPolicy, y actions().

void QWidget::insertActions(QAction *before, const QList<QAction *> &actions)

Inserta la acción 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 before no es una acción válida para este widget.

Un QWidget puede tener como máximo una de cada acción.

Véase también removeAction(), QMenu, insertAction(), y contextMenuPolicy.

bool QWidget::isAncestorOf(const QWidget *child) const

Devuelve true si este widget es padre, (o abuelo y así sucesivamente hasta cualquier nivel), del widget dado child, y ambos widgets están dentro de la misma ventana; en caso contrario devuelve false.

bool QWidget::isEnabledTo(const QWidget *ancestor) const

Devuelve true si este widget se habilitaría si ancestor estuviera habilitado; en caso contrario devuelve false.

Este es el caso si ni el propio widget ni ninguno de sus padres hasta pero excluyendo ancestor han sido explícitamente deshabilitados.

isEnabledTo(0) devuelve false si este widget o cualquiera de sus ancestros ha sido desactivado explícitamente.

La palabra antecesor significa un widget padre dentro de la misma ventana.

Por lo tanto isEnabledTo(0) se detiene en la ventana de este widget, a diferencia de isEnabled() que también tiene en cuenta las ventanas padre.

Véase también setEnabled() y enabled.

bool QWidget::isHidden() const

Devuelve true si el widget está oculto, en caso contrario devuelve false.

Un widget oculto sólo se hará visible cuando se llame a show(). No se mostrará automáticamente cuando se muestre el widget padre.

Para comprobar la visibilidad, utilice !isVisible() en su lugar (observe el signo de exclamación).

isHidden() implica !isVisible(), pero un widget puede no ser visible y no estar oculto al mismo tiempo. Este es el caso de los widgets que son hijos de widgets que no son visibles.

Los widgets están ocultos si

• se crearon como ventanas independientes,
• se crearon como hijos de widgets visibles,
• hide() o setVisible(false).

bool QWidget::isVisibleTo(const QWidget *ancestor) const

Devuelve true si este widget se hace visible si se muestra ancestor; en caso contrario devuelve false.

El caso verdadero ocurre si ni el widget mismo ni ningún padre hasta pero excluyendo ancestor ha sido explícitamente ocultado.

Esta función seguirá devolviendo true si el widget está oculto por otras ventanas en la pantalla, pero podría ser físicamente visible si él o ellas se movieran.

isVisibleTo(0) es idéntico a isVisible().

Véase también show(), hide() y isVisible().

bool QWidget::isWindow() const

Devuelve true si el widget es una ventana independiente, en caso contrario devuelve false.

Una ventana es un widget que no es visualmente hijo de ningún otro widget y que suele tener un marco y un window title.

Una ventana puede tener un parent widget. Entonces se agrupará con su padre y se borrará cuando se borre el padre, se minimizará cuando se minimice el padre, etc. Si el gestor de ventanas lo permite, también tendrá una entrada común en la barra de tareas con su ventana principal.

QDialog y QMainWindow son ventanas por defecto, incluso si se especifica un widget padre en el constructor. Este comportamiento se especifica mediante la bandera Qt::Window.

Véase también window(), isModal(), y parentWidget().

[virtual protected] void QWidget::keyPressEvent(QKeyEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de pulsación de teclas para el widget.

Un widget debe llamar a setFocusPolicy() para aceptar el foco inicialmente y tener el foco para recibir un evento de pulsación de tecla.

Si reimplementas este manejador, es muy importante que llames a la implementación de la clase base si no actúas sobre la tecla.

La implementación por defecto cierra los widgets emergentes si el usuario pulsa la secuencia de teclas para QKeySequence::Cancel (normalmente la tecla Escape). En caso contrario, el evento se ignora, para que el padre del widget pueda interpretarlo.

Tenga en cuenta que QKeyEvent comienza con isAccepted() == true, por lo que no necesita llamar a QKeyEvent::accept() - simplemente no llame a la implementación de la clase base si actúa sobre la tecla.

Ver también keyReleaseEvent(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event(), y QKeyEvent.

[virtual protected] void QWidget::keyReleaseEvent(QKeyEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de liberación de teclas para el widget.

Un widget debe accept focus inicialmente y have focus para recibir un evento de liberación de tecla.

Si reimplementas este manejador, es muy importante que llames a la implementación de la clase base si no actúas sobre la tecla.

La implementación por defecto ignora el evento, para que el padre del widget pueda interpretarlo.

Ten en cuenta que QKeyEvent comienza con isAccepted() == true, así que no necesitas llamar a QKeyEvent::accept() - simplemente no llames a la implementación de la clase base si actúas sobre la tecla.

Ver también keyPressEvent(), QEvent::ignore(), setFocusPolicy(), focusInEvent(), focusOutEvent(), event(), y QKeyEvent.

[static] QWidget *QWidget::keyboardGrabber()

Devuelve el widget que está capturando actualmente la entrada del teclado.

Si no hay ningún widget en esta aplicación que esté capturando el teclado, se devuelve nullptr.

Véase también grabMouse() y mouseGrabber().

QLayout *QWidget::layout() const

Devuelve el gestor de diseño que está instalado en este widget, o nullptr si no hay ningún gestor de diseño instalado.

El gestor de diseño establece la geometría de los hijos del widget que se han añadido al diseño.

Véase también setLayout(), sizePolicy() y Gestión de la presentación.

[virtual protected] void QWidget::leaveEvent(QEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de salida del widget que son pasados en el parámetro event.

Un evento leave se envía al widget cuando el cursor del ratón abandona el widget.

Ver también enterEvent(), mouseMoveEvent(), y event().

[slot] void QWidget::lower()

Baja el widget a la parte inferior de la pila del widget padre.

Después de esta llamada, el widget quedará visualmente detrás (y, por tanto, oculto) de cualquier widget hermano superpuesto.

Véase también raise() y stackUnder().

[since 6.0] QPointF QWidget::mapFrom(const QWidget *parent, const QPointF &pos) const

Traduce la coordenada del widget pos desde el sistema de coordenadas de parent al sistema de coordenadas de este widget. El parent no debe ser nullptr y debe ser un padre del widget que llama.

Esta función se introdujo en Qt 6.0.

Ver también mapTo(), mapFromParent(), mapFromGlobal(), y underMouse().

QPoint QWidget::mapFrom(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromGlobal(const QPointF &pos) const

Traduce las coordenadas globales de la pantalla pos a coordenadas del widget.

Esta función se introdujo en Qt 6.0.

Véase también mapToGlobal(), mapFrom(), y mapFromParent().

QPoint QWidget::mapFromGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapFromParent(const QPointF &pos) const

Traduce las coordenadas del widget padre pos a coordenadas del widget.

Igual que mapFromGlobal() si el widget no tiene padre.

Esta función se introdujo en Qt 6.0.

Véase también mapToParent(), mapFrom(), mapFromGlobal(), y underMouse().

QPoint QWidget::mapFromParent(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapTo(const QWidget *parent, const QPointF &pos) const

Traduce la coordenada del widget pos al sistema de coordenadas de parent. parent no debe ser nullptr y debe ser uno de los padres del widget invocador.

Esta función se introdujo en Qt 6.0.

Véase también mapFrom(), mapToParent(), mapToGlobal(), y underMouse().

QPoint QWidget::mapTo(const QWidget *parent, const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToGlobal(const QPointF &pos) const

Traduce las coordenadas del widget pos a coordenadas globales de pantalla. Por ejemplo, mapToGlobal(QPointF(0,0)) daría las coordenadas globales del píxel superior izquierdo del widget.

Esta función se introdujo en Qt 6.0.

Véase también mapFromGlobal(), mapTo(), y mapToParent().

QPoint QWidget::mapToGlobal(const QPoint &pos) const

[since 6.0] QPointF QWidget::mapToParent(const QPointF &pos) const

Traduce la coordenada del widget pos a una coordenada del widget padre.

Igual que mapToGlobal() si el widget no tiene padre.

Esta función se introdujo en Qt 6.0.

Véase también mapFromParent(), mapTo(), mapToGlobal(), y underMouse().

QPoint QWidget::mapToParent(const QPoint &pos) const

QRegion QWidget::mask() const

Devuelve la máscara actualmente establecida en un widget. Si no se ha establecido ninguna máscara, el valor devuelto será una región vacía.

Véase también setMask(), clearMask() y QRegion::isEmpty().

[override virtual protected] int QWidget::metric(QPaintDevice::PaintDeviceMetric m) const

Reimplementa: QPaintDevice::metric(QPaintDevice::PaintDeviceMetric) const.

Implementación interna de la función virtual QPaintDevice::metric().

m es la métrica a obtener.

[virtual protected] void QWidget::mouseDoubleClickEvent(QMouseEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de doble click del ratón para el widget.

La implementación por defecto llama a mousePressEvent().

Ver también mousePressEvent(), mouseReleaseEvent(), mouseMoveEvent(), event(), y QMouseEvent.

[static] QWidget *QWidget::mouseGrabber()

Devuelve el widget que está capturando la entrada del ratón.

Si ningún widget de esta aplicación está capturando el ratón, se devuelve nullptr.

Véase también grabMouse() y keyboardGrabber().

[virtual protected] void QWidget::mouseMoveEvent(QMouseEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de movimiento del ratón para el widget.

Si el seguimiento del ratón está desactivado, los eventos de movimiento del ratón sólo se producen si se pulsa un botón del ratón mientras se mueve el ratón. Si el seguimiento del ratón está activado, los eventos de movimiento del ratón se producen incluso si no se pulsa ningún botón del ratón.

QMouseEvent::position() informa de la posición del cursor del ratón, relativa a este widget. Para los eventos de pulsar y soltar, la posición suele ser la misma que la del último evento de movimiento del ratón, pero puede ser diferente si la mano del usuario tiembla. Esta es una característica del sistema de ventanas subyacente, no de Qt.

Si desea mostrar un tooltip inmediatamente, mientras el ratón se está moviendo (por ejemplo, para obtener las coordenadas del ratón con QMouseEvent::position() y mostrarlas como tooltip), primero debe activar el seguimiento del ratón como se ha descrito anteriormente. Después, para asegurarse de que la información sobre herramientas se actualiza inmediatamente, debe llamar a QToolTip::showText() en lugar de a setToolTip() en su implementación de mouseMoveEvent().

Véase también setMouseTracking(), mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), event(), QMouseEvent, y Scribble Example.

[virtual protected] void QWidget::mousePressEvent(QMouseEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de pulsación de ratón para el widget.

Si creas nuevos widgets en el evento mousePressEvent() el mouseReleaseEvent() puede no acabar donde esperas, dependiendo del sistema de ventanas subyacente (o del gestor de ventanas X11), de la localización de los widgets y quizás de más cosas.

La implementación por defecto implementa el cierre de los widgets emergentes cuando se pulsa fuera de la ventana. Para otros tipos de widgets no hace nada.

Véase también mouseReleaseEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent, y Scribble Example.

[virtual protected] void QWidget::mouseReleaseEvent(QMouseEvent *event)

Este manejador de eventos, para el evento event, puede ser reimplementado en una subclase para recibir eventos de liberación del ratón para el widget.

Ver también mousePressEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent, y Scribble Example.

void QWidget::move(int x, int y)

Esto corresponde a move(QPoint(x, y)).

[virtual protected] void QWidget::moveEvent(QMoveEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de movimiento del widget que se pasan en el parámetro event. Cuando el widget recibe este evento, ya se encuentra en la nueva posición.

La posición anterior es accesible a través de QMoveEvent::oldPos().

Ver también resizeEvent(), event(), move(), y QMoveEvent.

[virtual protected] bool QWidget::nativeEvent(const QByteArray &eventType, void *message, qintptr *result)

Este manejador de eventos especial puede ser reimplementado en una subclase para recibir eventos nativos de la plataforma identificados por eventType que son pasados en el parámetro message.

En su reimplementación de esta función, si desea que Qt deje de manejar el evento, devuelva true y establezca result. El parámetro result sólo tiene sentido en Windows. Si devuelves false, este evento nativo se devuelve a Qt, que traduce el evento a un evento Qt y lo envía al widget.

Véase también QAbstractNativeEventFilter.

QWidget *QWidget::nativeParentWidget() const

Devuelve el padre nativo de este widget, es decir, el siguiente widget ancestro que tiene un identificador de sistema, o nullptr si no tiene ningún padre nativo.

Véase también effectiveWinId().

QWidget *QWidget::nextInFocusChain() const

Devuelve el siguiente widget en la cadena de enfoque de este widget.

Véase también previousInFocusChain().

void QWidget::overrideWindowFlags(Qt::WindowFlags flags)

Establece las banderas de ventana para el widget a flags, sin decírselo al sistema de ventanas.

Véase también setWindowFlags().

[override virtual] QPaintEngine *QWidget::paintEngine() const

Reimplementa: QPaintDevice::paintEngine() const.

Devuelve el motor de pintura del widget.

Tenga en cuenta que esta función no debe ser llamada explícitamente por el usuario, ya que está pensada sólo para propósitos de reimplementación. La función es llamada por Qt internamente, y la implementación por defecto puede no devolver siempre un puntero válido.

[virtual protected] void QWidget::paintEvent(QPaintEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de pintura pasados en event.

Un evento paint es una petición para repintar todo o parte de un widget. Puede ocurrir por una de las siguientes razones:

• repaint() o update() fue invocado,
• el widget estaba oculto y ahora ha sido descubierto, o
• muchas otras razones.

Muchos widgets pueden simplemente repintar toda su superficie cuando se les pide, pero algunos widgets lentos necesitan optimizar pintando sólo la región solicitada: QPaintEvent::region(). Esta optimización de la velocidad no cambia el resultado, ya que la pintura se recorta a esa región durante el procesamiento de eventos. QListView y QTableView hacen esto, por ejemplo.

Qt también intenta acelerar el pintado combinando varios eventos de pintado en uno. Cuando update() es llamado varias veces o el sistema de ventanas envía varios eventos de pintado, Qt fusiona estos eventos en uno solo con una región mayor (ver QRegion::united()). La función repaint() no permite esta optimización, por lo que sugerimos utilizar update() siempre que sea posible.

Cuando se produce el evento paint, la región de actualización normalmente se ha borrado, por lo que estás pintando sobre el fondo del widget.

El fondo puede establecerse usando setBackgroundRole() y setPalette().

Desde Qt 4.0, QWidget automáticamente hace doble buffer en su pintura, así que no hay necesidad de escribir código de doble buffer en paintEvent() para evitar el parpadeo.

Ver también event(), repaint(), update(), QPainter, QPixmap, QPaintEvent, y Reloj Analógico.

QWidget *QWidget::parentWidget() const

Devuelve el widget padre de este widget, o nullptr si no tiene ningún widget padre.

QWidget *QWidget::previousInFocusChain() const

La función previousInFocusChain devuelve el widget anterior en la cadena de enfoque de este widget.

Véase también nextInFocusChain().

[slot] void QWidget::raise()

Eleva este widget a la parte superior de la pila del widget padre.

Después de esta llamada el widget estará visualmente delante de cualquier widget hermano superpuesto.

Véase también lower() y stackUnder().

void QWidget::releaseKeyboard()

Libera el teclado.

Véase también grabKeyboard(), grabMouse() y releaseMouse().

void QWidget::releaseMouse()

Libera el agarre del ratón.

Véase también grabMouse(), grabKeyboard() y releaseKeyboard().

void QWidget::releaseShortcut(int id)

Elimina el acceso directo con la dirección id del sistema de accesos directos de Qt. El widget dejará de recibir eventos QEvent::Shortcut para la secuencia de teclas del acceso directo (a menos que tenga otros accesos directos con la misma secuencia de teclas).

Véase también grabShortcut() y setShortcutEnabled().

void QWidget::removeAction(QAction *action)

Elimina la acción action de la lista de acciones de este widget.

Véase también insertAction() y actions().

void QWidget::render(QPaintDevice *target, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Renderiza el sourceRegion de este widget en el target usando renderFlags para determinar cómo renderizar. La renderización comienza en targetOffset en el target. Por ejemplo:

QPixmap pixmap(widget->size());
widget->render(&pixmap);

Si sourceRegion es una región nula, esta función utilizará QWidget::rect() como región, es decir, todo el widget.

Asegúrese de llamar a QPainter::end() para el pintor activo del dispositivo target (si existe) antes de renderizar. Por ejemplo:

QPainter painter(this);
...
painter.end();
myWidget->render(this);

void QWidget::render(QPainter *painter, const QPoint &targetOffset = QPoint(), const QRegion &sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))

Renderiza el widget en el painter's QPainter::device().

Las transformaciones y los ajustes aplicados a painter se utilizarán al renderizar.

Véase también QPainter::device().

[slot] void QWidget::repaint()

Repinta el widget directamente llamando a paintEvent() inmediatamente, a menos que las actualizaciones estén desactivadas o el widget esté oculto.

Sugerimos utilizar repaint() sólo si necesita un repintado inmediato, por ejemplo durante una animación. En la mayoría de las circunstancias update() es mejor, ya que permite a Qt optimizar la velocidad y minimizar el parpadeo.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::repaint));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->repaint(); });

Véase también update(), paintEvent() y setUpdatesEnabled().

void QWidget::repaint(const QRect &rect)

Esta versión repinta un rectángulo rect dentro del widget.

void QWidget::repaint(const QRegion &rgn)

Esta versión repinta una región rgn dentro del widget.

void QWidget::repaint(int x, int y, int w, int h)

Esta versión repinta un rectángulo (x, y, w, h) dentro del widget.

Si w es negativo, se sustituye por width() - x, y si h es negativo, se sustituye por height() - y.

void QWidget::resize(int w, int h)

Esto corresponde a resize(QSize(w, h)).

[virtual protected] void QWidget::resizeEvent(QResizeEvent *event)

Este manejador de eventos puede ser reimplementado en una subclase para recibir eventos de redimensionamiento del widget que se pasan en el parámetro event. Cuando se llama a resizeEvent(), el widget ya tiene su nueva geometría. El tamaño antiguo es accesible a través de QResizeEvent::oldSize().

El widget se borrará y recibirá un evento paint inmediatamente después de procesar el evento resize. No es necesario (ni debería) dibujar dentro de este manejador.

Ver también moveEvent(), event(), resize(), QResizeEvent, paintEvent(), y Scribble Example.

bool QWidget::restoreGeometry(const QByteArray &geometry)

Restaura la geometría y el estado de los widgets de nivel superior almacenados en la matriz de bytes geometry. Devuelve true en caso de éxito; en caso contrario devuelve false.

Si la geometría restaurada está fuera de la pantalla, se modificará para que esté dentro de la geometría de pantalla disponible.

Para restaurar la geometría guardada mediante QSettings, puede utilizar código como éste:

QSettings settings("MyCompany", "MyApp");
myWidget->restoreGeometry(settings.value("myWidget/geometry").toByteArray());

Consulte la documentación Geometría de ventanas para obtener una visión general de los problemas de geometría con ventanas.

Utilice QMainWindow::restoreState() para restaurar la geometría y el estado de las barras de herramientas y los widgets del dock.

Véase también saveGeometry(), QSettings, QMainWindow::saveState(), y QMainWindow::restoreState().

QByteArray QWidget::saveGeometry() const

Guarda la geometría actual y el estado de los widgets de nivel superior.

Para guardar la geometría cuando la ventana se cierra, puedes implementar un evento de cierre como este:

void MyWidget::closeEvent(QCloseEvent *event)
{
    QSettings settings("MyCompany", "MyApp");
    settings.setValue("geometry", saveGeometry());
    QWidget::closeEvent(event);
}

Consulta la documentación de Geometría de Ventanas para una visión general de los problemas de geometría con ventanas.

Utiliza QMainWindow::saveState() para guardar la geometría y el estado de las barras de herramientas y los widgets del dock.

Véase también restoreGeometry(), QMainWindow::saveState(), y QMainWindow::restoreState().

QScreen *QWidget::screen() const

Devuelve la pantalla en la que se encuentra el widget.

Véase también setScreen() y windowHandle().

void QWidget::scroll(int dx, int dy)

Desplaza el widget incluyendo sus hijos dx píxeles hacia la derecha y dy hacia abajo. Tanto dx como dy pueden ser negativos.

Después del desplazamiento, los widgets recibirán eventos de pintura para las áreas que necesiten ser repintadas. Para los widgets que Qt sabe que son opacos, esto es sólo las partes recién expuestas. Por ejemplo, si un widget opaco se desplaza 8 píxeles a la izquierda, sólo una franja de 8 píxeles de ancho en el borde derecho necesita ser actualizada.

Dado que los widgets propagan el contenido de sus padres por defecto, necesitas establecer la propiedad autoFillBackground, o usar setAttribute() para establecer el atributo Qt::WA_OpaquePaintEvent, para hacer un widget opaco.

Para los widgets que utilizan la propagación de contenidos, un desplazamiento provocará una actualización de toda el área de desplazamiento.

Véase también Transparency and Double Buffering.

void QWidget::scroll(int dx, int dy, const QRect &r)

Esta versión sólo desplaza r y no mueve los hijos del widget.

Si r está vacío o no es válido, el resultado es indefinido.

Véase también QScrollArea.

void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on = true)

Establece el atributo attribute en este widget si on es verdadero; en caso contrario, borra el atributo.

Véase también testAttribute().

void QWidget::setBackgroundRole(QPalette::ColorRole role)

Establece el rol de fondo del widget en role.

El rol de fondo define el pincel de palette del widget que se utiliza para representar el fondo.

Si role es QPalette::NoRole, entonces el widget hereda el rol de fondo de su padre.

Tenga en cuenta que los estilos son libres de elegir cualquier color de la paleta. Puedes modificar la paleta o establecer una hoja de estilo si no obtienes el resultado que deseas con setBackgroundRole().

Véase también backgroundRole() y foregroundRole().

void QWidget::setBaseSize(int basew, int baseh)

Esto corresponde a setBaseSize(QSize(basew, baseh)). Establece el tamaño base de los widgets a la anchura basew y la altura baseh.

Véase también baseSize().

void QWidget::setContentsMargins(int left, int top, int right, int bottom)

Establece los márgenes alrededor del contenido del widget para que tengan los tamaños left, top, right, y bottom. Los márgenes son utilizados por el sistema de diseño, y pueden ser utilizados por subclases para especificar el área a dibujar (por ejemplo, excluyendo el marco).

Si se cambian los márgenes, se activará resizeEvent().

Véase también contentsRect() y contentsMargins().

void QWidget::setContentsMargins(const QMargins &margins)

La función setContentsMargins establece los márgenes alrededor del contenido del widget.

Establece los márgenes alrededor del contenido del widget para que tengan los tamaños determinados por margins. Los márgenes son utilizados por el sistema de diseño, y pueden ser utilizados por subclases para especificar el área a dibujar (por ejemplo, excluyendo el marco).

Al cambiar los márgenes se activará una función resizeEvent().

Véase también contentsRect() y contentsMargins().

[slot] void QWidget::setDisabled(bool disable)

Desactiva los eventos de entrada del widget si disable es verdadero; en caso contrario, activa los eventos de entrada.

Consulte la documentación de enabled para obtener más información.

Véase también isEnabledTo(), QKeyEvent, QMouseEvent, y changeEvent().

void QWidget::setEditFocus(bool enable)

Si enable es verdadero, hace que este widget tenga el foco de edición, en cuyo caso Qt::Key_Up y Qt::Key_Down se entregarán al widget normalmente; en caso contrario, Qt::Key_Up y Qt::Key_Down se utilizan para cambiar el foco.

Esta característica sólo está disponible en Qt para Embedded Linux.

Ver también hasEditFocus() y QApplication::navigationMode().

void QWidget::setFixedHeight(int h)

Establece las alturas mínima y máxima del widget en h sin cambiar las anchuras. Se proporciona por comodidad.

Véase también sizeHint(), minimumSize(), maximumSize() y setFixedSize().

void QWidget::setFixedSize(const QSize &s)

Establece los tamaños mínimo y máximo del widget en s, impidiendo así que crezca o se reduzca.

Esto anulará las restricciones de tamaño por defecto establecidas por QLayout.

Para eliminar las restricciones, establece el tamaño en QWIDGETSIZE_MAX.

Alternativamente, si desea que el widget tenga un tamaño fijo basado en su contenido, puede llamar a QLayout::setSizeConstraint(QLayout::SetFixedSize);

Véase también maximumSize y minimumSize.

void QWidget::setFixedSize(int w, int h)

Establece la anchura del widget en w y la altura en h.

void QWidget::setFixedWidth(int w)

Establece la anchura mínima y máxima del widget en w sin cambiar las alturas. Se proporciona por comodidad.

Véase también sizeHint(), minimumSize(), maximumSize() y setFixedSize().

void QWidget::setFocus(Qt::FocusReason reason)

Da el foco de entrada de teclado a este widget (o a su proxy de foco) si este widget o uno de sus padres es el active window. El argumento reason se pasará a cualquier evento de foco enviado desde esta función, se usa para dar una explicación de qué causó que el widget obtuviera el foco. Si la ventana no está activa, el widget recibirá el foco cuando la ventana se active.

Primero, se envía un evento focus about to change al widget focus (si lo hay) para decirle que está a punto de perder el foco. Entonces se cambia el foco, se envía un evento de foco fuera al elemento de foco anterior y se envía un evento de foco dentro al nuevo elemento para decirle que acaba de recibir el foco. (No ocurre nada si los widgets focus in y focus out son el mismo).

setFocus() da el foco a un widget independientemente de su política de foco, pero no borra ninguna captura de teclado (ver grabKeyboard()).

Ten en cuenta que si el widget está oculto, no aceptará el foco hasta que sea mostrado.

Ver también hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), Enfoque del teclado en widgets, y QEvent::RequestSoftwareInputPanel.

[slot] void QWidget::setFocus()

Da el foco de entrada de teclado a este widget (o a su proxy de foco) si este widget o uno de sus padres es el active window.

// Connect using qOverload:
connect(sender, &SenderClass::signal,
        widget, qOverload<>(&QWidget::setFocus));

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->setFocus(); });

void QWidget::setFocusProxy(QWidget *w)

Establece el proxy de foco del widget en el widget w. Si w es nullptr, la función restablece este widget para que no tenga proxy de foco.

Algunos widgets pueden "tener foco", pero crean un widget hijo, como QLineEdit, para manejar realmente el foco. En este caso, el widget puede establecer que la línea edit sea su proxy de foco.

setFocusProxy() establece el widget que realmente obtendrá el foco cuando "este widget" lo obtenga. Si hay un proxy de foco, setFocus() y hasFocus() operan sobre el proxy de foco. Si "este widget" es el widget de foco, entonces setFocusProxy() mueve el foco al nuevo proxy de foco.

Véase también focusProxy().

void QWidget::setForegroundRole(QPalette::ColorRole role)

Establece el rol de primer plano del widget en role.

El rol de primer plano define el color de palette del widget que se utiliza para dibujar el primer plano.

Si role es QPalette::NoRole, el widget utiliza un rol de primer plano que contrasta con el rol de fondo.

Tenga en cuenta que los estilos son libres de elegir cualquier color de la paleta. Puede modificar la paleta o establecer una hoja de estilo si no consigue el resultado que desea con setForegroundRole().

Véase también foregroundRole() y backgroundRole().

void QWidget::setGeometry(int x, int y, int w, int h)

Corresponde a setGeometry(QRect(x, y, w, h)).

Véase también geometry().

void QWidget::setGraphicsEffect(QGraphicsEffect *effect)

La función setGraphicsEffect sirve para establecer el efecto gráfico del widget.

Establece effect como efecto del widget. Si ya hay un efecto instalado en este widget, QWidget borrará el efecto existente antes de instalar el nuevo effect.

Si effect es el efecto instalado en un widget diferente, setGraphicsEffect() eliminará el efecto del widget y lo instalará en este widget.

QWidget toma posesión de effect.

Véase también graphicsEffect().

[slot] void QWidget::setHidden(bool hidden)

Función de conveniencia, equivalente a setVisible(!hidden).

Véase también isHidden().

void QWidget::setLayout(QLayout *layout)

Establece el gestor de diseño para este widget en layout.

Si ya hay un gestor de diseño instalado en este widget, QWidget no te permitirá instalar otro. Primero debes borrar el gestor de diseño existente (devuelto por layout()) antes de poder llamar a setLayout() con el nuevo diseño.

Si layout es el gestor de diseño de un widget diferente, setLayout() reparentará el diseño y lo convertirá en el gestor de diseño de este widget.

Ejemplo:

QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(formWidget);
formWidget->setLayout(layout);

Una alternativa a llamar a esta función es pasar este widget al constructor del layout.

El QWidget tomará la propiedad de layout.

Véase también layout() y Gestión de la presentación.

void QWidget::setMask(const QBitmap &bitmap)

Hace que sólo sean visibles los píxeles del widget para los que bitmap tiene un bit 1 correspondiente. Si la región incluye píxeles fuera de rect() del widget, los controles del sistema de ventanas en esa área pueden o no ser visibles, dependiendo de la plataforma.

Tenga en cuenta que este efecto puede ser lento si la región es particularmente compleja.

El siguiente código muestra cómo se puede utilizar una imagen con un canal alfa para generar una máscara para un widget:

QLabel topLevelLabel;
QPixmap pixmap(":/images/tux.png");
topLevelLabel.setPixmap(pixmap);
topLevelLabel.setMask(pixmap.mask());

La etiqueta mostrada por este código es enmascarada usando la imagen que contiene, dando la apariencia de que una imagen de forma irregular está siendo dibujada directamente en la pantalla.

Los widgets enmascarados sólo reciben eventos del ratón en sus partes visibles.

Véase también mask(), clearMask(), y windowOpacity().

void QWidget::setMask(const QRegion &region)

Hace que sólo sean visibles las partes del widget que se solapan con region. Si la región incluye píxeles fuera de rect() del widget, los controles del sistema de ventanas en esa área pueden o no ser visibles, dependiendo de la plataforma.

Dado que QRegion permite crear regiones arbitrariamente complejas, las máscaras de widget pueden adaptarse a las ventanas con formas menos convencionales, e incluso permitir que los widgets se muestren con agujeros. Tenga en cuenta que este efecto puede ser lento si la región es particularmente compleja.

Las máscaras de widget se utilizan para indicar al sistema de ventanas que la aplicación no desea eventos de ratón para áreas fuera de la máscara. En la mayoría de los sistemas, también producen un recorte visual grueso. Para obtener bordes de ventana suaves, utilice en su lugar fondo translúcido y pintura anti-aliasing, como se muestra en el ejemplo Fondo translúcido.

Véase también windowOpacity.

void QWidget::setMaximumSize(int maxw, int maxh)

Esta función corresponde a setMaximumSize(QSize(maxw, maxh)). Establece la anchura máxima en maxw y la altura máxima en maxh.

Véase también maximumSize().

void QWidget::setMinimumSize(int minw, int minh)

Esta función corresponde a setMinimumSize(QSize(minw, minh)). Establece la anchura mínima en minw y la altura mínima en minh.

Véase también minimumSize().

void QWidget::setParent(QWidget *parent)

Establece el padre del widget en parent, y restablece los indicadores de la ventana. El widget se mueve a la posición (0, 0) en su nuevo padre.

Si el nuevo widget padre está en una ventana diferente, el widget reparentado y sus hijos se añaden al final de tab chain del nuevo widget padre, en el mismo orden interno que antes. Si uno de los widgets movidos tenía el foco del teclado, setParent() llama a clearFocus() para ese widget.

Si el nuevo widget padre está en la misma ventana que el padre anterior, establecer el padre no cambia el orden de las pestañas o el foco del teclado.

Si el "nuevo" widget padre es el antiguo widget padre, esta función no hace nada.

Véase también setWindowFlags().

void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)

Esta función también toma como argumento widget flags, f.

void QWidget::setScreen(QScreen *screen)

Establece la pantalla en la que debe mostrarse el widget en screen.

Establecer la pantalla sólo tiene sentido para las ventanas. Si es necesario, la ventana del widget se volverá a crear en screen.

Véase también screen() y QWindow::setScreen().

void QWidget::setShortcutAutoRepeat(int id, bool enable = true)

Si enable es verdadero, se activa la repetición automática del acceso directo con el id dado; en caso contrario, se desactiva.

Véase también grabShortcut() y releaseShortcut().

void QWidget::setShortcutEnabled(int id, bool enable = true)

Si enable es verdadero, se activa el acceso directo con el id dado; en caso contrario, el acceso directo se desactiva.

Véase también grabShortcut() y releaseShortcut().

void QWidget::setSizeIncrement(int w, int h)

Establece el incremento de tamaño x (anchura) en w y el incremento de tamaño y (altura) en h.

Véase también sizeIncrement().

void QWidget::setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical)

Establece la política de tamaño del widget en horizontal y vertical, con estiramiento estándar y sin altura por anchura.

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

void QWidget::setStyle(QStyle *style)

Establece el estilo GUI del widget en style. La propiedad del objeto estilo no se transfiere.

Si no se establece ningún estilo, el widget utiliza el estilo de la aplicación, QApplication::style() en su lugar.

Establecer el estilo de un widget no afecta a los widgets hijos existentes o futuros.

Ver también style(), QStyle, QApplication::style(), y QApplication::setStyle().

[static] void QWidget::setTabOrder(QWidget *first, QWidget *second)

Coloca el widget second después del widget first en el orden de foco.

De hecho, elimina el widget second de su cadena de enfoque y lo inserta después del widget first.

Tenga en cuenta que, dado que se cambia el orden de tabulación del widget second, debe ordenar la cadena así:

setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to d

no 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 d

Si first o second tiene un proxy de foco, setTabOrder() sustituye correctamente al proxy.

Véase también setFocusPolicy(), setFocusProxy(), y Enfoque de teclado en widgets.

[static, since 6.6] void QWidget::setTabOrder(std::initializer_list<QWidget *> widgets)

Establece el orden de tabulación para los widgets en la lista widgets llamando a QWidget::setTabOrder(QWidget *, QWidget *) para cada par consecutivo de widgets.

En lugar de establecer cada par manualmente de esta manera:

setTabOrder(a, b); // a to b
setTabOrder(b, c); // a to b to c
setTabOrder(c, d); // a to b to c to d

puedes llamar:

setTabOrder({a, b, c, d}); // a to b to c to d

La llamada no crea un bucle cerrado de enfoque de pestaña. Si hay más widgets con la política de foco Qt::TabFocus, al tabular en d se moverá el foco a uno de esos widgets, no de vuelta a a.

Esta función se introdujo en Qt 6.6.

Ver también setFocusPolicy(), setFocusProxy(), y Enfoque de Teclado en Widgets.

void QWidget::setWindowFlag(Qt::WindowType flag, bool on = true)

Establece la bandera de ventana flag en este widget si on es verdadero; en caso contrario borra la bandera.

Véase también setWindowFlags(), windowFlags(), y windowType().

void QWidget::setWindowRole(const QString &role)

Establece el rol de la ventana a role. Esto sólo tiene sentido para ventanas en X11.

Véase también windowRole().

void QWidget::setWindowState(Qt::WindowStates windowState)

Establece el estado de la ventana en windowState. El estado de la ventana es una combinación OR'ed de Qt::WindowState: Qt::WindowMinimized, Qt::WindowMaximized, Qt::WindowFullScreen, y Qt::WindowActive.

Si la ventana no es visible (es decir, isVisible() devuelve false), el estado de la ventana tendrá efecto cuando se llame a show(). Para las ventanas visibles, el cambio es inmediato. Por ejemplo, para alternar entre pantalla completa y modo normal, utilice el siguiente código:

w->setWindowState(w->windowState() ^ Qt::WindowFullScreen);

Para restaurar y activar una ventana minimizada (conservando su estado maximizado y/o de pantalla completa), utilice lo siguiente:

w->setWindowState((w->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);

Al llamar a esta función se ocultará el widget. Debe llamar a show() para que el widget vuelva a ser visible.

Cuando el estado de la ventana cambia, el widget recibe un changeEvent() de tipo QEvent::WindowStateChange.

Véase también Qt::WindowState y windowState().

void QWidget::setupUi(QWidget *widget)

Configura la interfaz de usuario para el widget especificado.

Véase también Uso de un archivo de interfaz de usuario de Designer en la aplicación.