En esta página

QWidget Class

La clase QWidget es la clase base de todos los objetos de la interfaz de usuario. Más información...

Tipos públicos

enum RenderFlag { DrawWindowBackground, DrawChildren, IgnoreMask }
flags RenderFlags

Propiedades

Funciones públicas

QWidget(QWidget*parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())
virtual ~QWidget()
bool acceptDrops() const
QString accessibleDescription() const
QString accessibleIdentifier() const
QString accessibleName() const
QList<QAction *> actions() const
void activateWindow()
void addAction(QAction*acción)
(since 6.3) QAction *addAction(const QString&text)
(since 6.3) QAction *addAction(const QIcon&icono, const QString&texto)
(since 6.3) QAction *addAction(const QString&text, const QKeySequence&shortcut)
(since 6.3) QAction *addAction(const QIcon&icon, const QString&text, const QKeySequence&shortcut)
(since 6.3) QAction *addAction(const QString&text, Args &&... args)
(since 6.3) QAction *addAction(const QIcon&icon, const QString&text, Args &&... args)
(since 6.3) QAction *addAction(const QString&text, const QKeySequence&shortcut, Args &&... args)
(since 6.3) QAction *addAction(const QIcon&icon, const QString&text, const QKeySequence&shortcut, Args &&... args)
(since 6.3) QAction *addAction(const QString&text, const QObject*receptor, const char*miembro, Qt::ConnectionType tipo = Qt::AutoConnection)
(since 6.3) QAction *addAction(const QIcon&icon, const QString&text, const QObject*receiver, const char*member, Qt::ConnectionType type = Qt::AutoConnection)
(since 6.3) QAction *addAction(const QString&text, const QKeySequence&shortcut, const QObject*receiver, const char*member, Qt::ConnectionType type = Qt::AutoConnection)
(since 6.3) QAction *addAction(const QIcon&icon, const QString&text, const QKeySequence&shortcut, const QObject*receiver, const char*member, Qt::ConnectionType type = Qt::AutoConnection)
void addActions(const QList<QAction *>&actions)
void adjustSize()
bool autoFillBackground() const
QPalette::ColorRole backgroundRole() const
QBackingStore *backingStore() const
QSize baseSize() const
QWidget *childAt(int x, int y) const
QWidget *childAt(const QPoint&p) const
(since 6.8) QWidget *childAt(const QPointF&p) const
QRect childrenRect() const
QRegion childrenRegion() const
void clearFocus()
void clearMask()
QMargins contentsMargins() const
QRect contentsRect() const
Qt::ContextMenuPolicy contextMenuPolicy() const
QCursor cursor() const
WId effectiveWinId() const
void ensurePolished() const
Qt::FocusPolicy focusPolicy() const
QWidget *focusProxy() const
QWidget *focusWidget() const
const QFont &font() const
QFontInfo fontInfo() const
QFontMetrics fontMetrics() const
QPalette::ColorRole foregroundRole() const
QRect frameGeometry() const
QSize frameSize() const
const QRect &geometry() const
QPixmap grab(const QRect&rectángulo = QRect(QPoint(0, 0), QSize(-1, -1)))
void grabGesture(Qt::GestureType gesto, Qt::GestureFlags indicadores = Qt::GestureFlags())
void grabKeyboard()
void grabMouse()
void grabMouse(const QCursor&cursor)
int grabShortcut(const QKeySequence&key, Qt::ShortcutContext context = Qt::WindowShortcut)
QGraphicsEffect *graphicsEffect() const
QGraphicsProxyWidget *graphicsProxyWidget() const
bool hasFocus() const
virtual bool hasHeightForWidth() const
bool hasMouseTracking() const
bool hasTabletTracking() const
int height() const
virtual int heightForWidth(int w) const
Qt::InputMethodHints inputMethodHints() const
virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const
void insertAction(QAction*before, QAction*action)
void insertActions(QAction*before, const QList<QAction *>&actions)
bool isActiveWindow() const
bool isAncestorOf(const QWidget*child) const
bool isEnabled() const
bool isEnabledTo(const QWidget*ancestor) const
bool isFullScreen() const
bool isHidden() const
bool isMaximized() const
bool isMinimized() const
bool isModal() const
bool isVisible() const
bool isVisibleTo(const QWidget*ancestor) const
bool isWindow() const
bool isWindowModified() const
QLayout *layout() const
Qt::LayoutDirection layoutDirection() const
QLocale locale() const
(since 6.0) QPointF mapFrom(const QWidget*parent, const QPointF&pos) const
QPoint mapFrom(const QWidget*parent, const QPoint&pos) const
(since 6.0) QPointF mapFromGlobal(const QPointF&pos) const
QPoint mapFromGlobal(const QPoint&pos) const
(since 6.0) QPointF mapFromParent(const QPointF&pos) const
QPoint mapFromParent(const QPoint&pos) const
(since 6.0) QPointF mapTo(const QWidget*parent, const QPointF&pos) const
QPoint mapTo(const QWidget*parent, const QPoint&pos) const
(since 6.0) QPointF mapToGlobal(const QPointF&pos) const
QPoint mapToGlobal(const QPoint&pos) const
(since 6.0) QPointF mapToParent(const QPointF&pos) const
QPoint mapToParent(const QPoint&pos) const
QRegion mask() const
int maximumHeight() const
QSize maximumSize() const
int maximumWidth() const
int minimumHeight() const
QSize minimumSize() const
virtual QSize minimumSizeHint() const
int minimumWidth() const
void move(int x, int y)
void move(const QPoint &)
QWidget *nativeParentWidget() const
QWidget *nextInFocusChain() const
QRect normalGeometry() const
void overrideWindowFlags(Qt::WindowFlags flags)
const QPalette &palette() const
QWidget *parentWidget() const
QPoint pos() const
QWidget *previousInFocusChain() const
QRect rect() const
void releaseKeyboard()
void releaseMouse()
void releaseShortcut(int id)
void removeAction(QAction*acción)
void render(QPaintDevice*target, const QPoint&targetOffset = QPoint(), const QRegion&sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))
void render(QPainter*painter, const QPoint&targetOffset = QPoint(), const QRegion&sourceRegion = QRegion(), QWidget::RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren))
void repaint(const QRect&rect)
void repaint(const QRegion&rgn)
void repaint(int x, int y, int w, int h)
void resize(int w, int h)
void resize(const QSize &)
bool restoreGeometry(const QByteArray&geometría)
QByteArray saveGeometry() const
QScreen *screen() const
void scroll(int dx, int dy)
void scroll(int dx, int dy, const QRect&r)
void setAcceptDrops(bool on)
void setAccessibleDescription(const QString&descripción)
void setAccessibleIdentifier(const QString&identificador)
void setAccessibleName(const QString&nombre)
void setAttribute(Qt::WidgetAttribute atributo, bool on = true)
void setAutoFillBackground(bool enabled)
void setBackgroundRole(QPalette::ColorRole role)
void setBaseSize(const QSize &)
void setBaseSize(int basew, int baseh)
void setContentsMargins(int izquierda, int arriba, int derecha, int abajo)
void setContentsMargins(const QMargins&margins)
void setContextMenuPolicy(Qt::ContextMenuPolicy policy)
void setCursor(const QCursor &)
void setFixedHeight(int h)
void setFixedSize(const QSize&s)
void setFixedSize(int w, int h)
void setFixedWidth(int w)
void setFocus(Qt::FocusReason motivo)
void setFocusPolicy(Qt::FocusPolicy policy)
void setFocusProxy(QWidget*w)
void setFont(const QFont &)
void setForegroundRole(QPalette::ColorRole role)
void setGeometry(int x, int y, int w, int h)
void setGeometry(const QRect &)
void setGraphicsEffect(QGraphicsEffect*efecto)
void setInputMethodHints(Qt::InputMethodHints hints)
void setLayout(QLayout*layout)
void setLayoutDirection(Qt::LayoutDirection direction)
void setLocale(const QLocale&locale)
void setMask(const QBitmap&bitmap)
void setMask(const QRegion&region)
void setMaximumHeight(int maxh)
void setMaximumSize(const QSize &)
void setMaximumSize(int maxw, int maxh)
void setMaximumWidth(int maxw)
void setMinimumHeight(int minh)
void setMinimumSize(const QSize &)
void setMinimumSize(int minw, int minh)
void setMinimumWidth(int minw)
void setMouseTracking(bool enable)
void setPalette(const QPalette &)
void setParent(QWidget*parent)
void setParent(QWidget*parent, Qt::WindowFlags f)
void setScreen(QScreen*screen)
void setShortcutAutoRepeat(int id, bool enable = true)
void setShortcutEnabled(int id, bool enable = true)
void setSizeIncrement(const QSize &)
void setSizeIncrement(int w, int h)
void setSizePolicy(QSizePolicy)
void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical)
void setStatusTip(const QString &)
void setStyle(QStyle*style)
void setTabletTracking(bool enable)
void setToolTip(const QString &)
void setToolTipDuration(int msec)
void setUpdatesEnabled(bool enable)
void setWhatsThis(const QString &)
void setWindowFilePath(const QString&rutaDelArchivo)
void setWindowFlag(Qt::WindowType flag, bool on = true)
void setWindowFlags(Qt::WindowFlags tipo)
void setWindowIcon(const QIcon&icon)
void setWindowModality(Qt::WindowModality windowModality)
void setWindowOpacity(qreal nivel)
void setWindowRole(const QString&role)
void setWindowState(Qt::WindowStates estado_ventana)
void setupUi(QWidget*widget)
QSize size() const
virtual QSize sizeHint() const
QSize sizeIncrement() const
QSizePolicy sizePolicy() const
void stackUnder(QWidget*w)
QString statusTip() const
QStyle *style() const
QString styleSheet() const
bool testAttribute(Qt::WidgetAttribute atributo) const
QString toolTip() const
int toolTipDuration() const
bool underMouse() const
void ungrabGesture(Qt::GestureType gesto)
void unsetCursor()
void unsetLayoutDirection()
void unsetLocale()
void update(const QRect&rect)
void update(const QRegion&rgn)
void update(int x, int y, int w, int h)
void updateGeometry()
bool updatesEnabled() const
QRegion visibleRegion() const
QString whatsThis() const
int width() const
WId winId() const
QWidget *window() const
QString windowFilePath() const
Qt::WindowFlags windowFlags() const
QWindow *windowHandle() const
QIcon windowIcon() const
Qt::WindowModality windowModality() const
qreal windowOpacity() const
QString windowRole() const
Qt::WindowStates windowState() const
QString windowTitle() const
Qt::WindowType windowType() const
int x() const
int y() const

Funciones públicas reimplementadas

virtual QPaintEngine *paintEngine() const override

Ranuras públicas

bool close()
void hide()
void lower()
void raise()
void repaint()
void setDisabled(bool disable)
void setEnabled(bool)
void setFocus()
void setHidden(bool hidden)
void setStyleSheet(const QString &styleSheet)
virtual void setVisible(bool visible)
void setWindowModified(bool)
void setWindowTitle(const QString &)
void show()
void showFullScreen()
void showMaximized()
void showMinimized()
void showNormal()
void update()

Señales

void customContextMenuRequested(const QPoint &pos)
void windowIconChanged(const QIcon &icon)
void windowTitleChanged(const QString &title)

Miembros públicos estáticos

QWidget *createWindowContainer(QWindow *window, QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags())
QWidget *find(WId id)
QWidget *keyboardGrabber()
QWidget *mouseGrabber()
void setTabOrder(QWidget *first, QWidget *second)
(since 6.6) void setTabOrder(std::initializer_list<QWidget *> widgets)

Funciones protegidas

virtual void actionEvent(QActionEvent *event)
virtual void changeEvent(QEvent *event)
virtual void closeEvent(QCloseEvent *event)
virtual void contextMenuEvent(QContextMenuEvent *event)
void create(WId window = 0, bool initializeWindow = true, bool destroyOldWindow = true)
void destroy(bool destroyWindow = true, bool destroySubWindows = true)
virtual void dragEnterEvent(QDragEnterEvent *event)
virtual void dragLeaveEvent(QDragLeaveEvent *event)
virtual void dragMoveEvent(QDragMoveEvent *event)
virtual void dropEvent(QDropEvent *event)
virtual void enterEvent(QEnterEvent *event)
virtual void focusInEvent(QFocusEvent *event)
bool focusNextChild()
virtual bool focusNextPrevChild(bool next)
virtual void focusOutEvent(QFocusEvent *event)
bool focusPreviousChild()
virtual void hideEvent(QHideEvent *event)
virtual void inputMethodEvent(QInputMethodEvent *event)
virtual void keyPressEvent(QKeyEvent *event)
virtual void keyReleaseEvent(QKeyEvent *event)
virtual void leaveEvent(QEvent *event)
virtual void mouseDoubleClickEvent(QMouseEvent *event)
virtual void mouseMoveEvent(QMouseEvent *event)
virtual void mousePressEvent(QMouseEvent *event)
virtual void mouseReleaseEvent(QMouseEvent *event)
virtual void moveEvent(QMoveEvent *event)
virtual bool nativeEvent(const QByteArray &eventType, void *message, qintptr *result)
virtual void paintEvent(QPaintEvent *event)
virtual void resizeEvent(QResizeEvent *event)
virtual void showEvent(QShowEvent *event)
virtual void tabletEvent(QTabletEvent *event)
virtual void wheelEvent(QWheelEvent *event)

Funciones protegidas reimplementadas

virtual bool event(QEvent*event) override
virtual void initPainter(QPainter*painter) const override
virtual int metric(QPaintDevice::PaintDeviceMetric m) const override

Ranuras protegidas

void updateMicroFocus(Qt::InputMethodQuery query = Qt::ImQueryAll)

Macros

Descripción detallada

El widget es el elemento básico de la interfaz de usuario: recibe eventos del ratón, del teclado y de otro tipo procedentes del sistema de ventanas, y dibuja una representación de sí mismo en la pantalla. Todos los widgets son rectangulares y se ordenan según el orden Z. Un widget queda recortado por su padre y por los widgets que se encuentran delante de él.

Un widget que no está incrustado en un widget padre se denomina ventana. Normalmente, las ventanas tienen un marco y una barra de título, aunque también es posible crear ventanas sin dicha decoración utilizando las clases adecuadas de ` window flags`. En Qt, ` QMainWindow ` y las diversas subclases de ` QDialog ` son los tipos de ventana más comunes.

El constructor de cada widget acepta uno o dos argumentos estándar:

  1. QWidget *parent = nullptr es el padre del nuevo widget. Si es nullptr (por defecto), el nuevo widget será una ventana. De lo contrario, será un hijo del padre y estará limitado por la geometría de este(a menos que se especifique Qt::Window como indicador de ventana).
  2. Qt::WindowFlags f = { } (cuando esté disponible) establece los indicadores de ventana; el valor por defecto es adecuado para la mayoría de los widgets, pero para obtener, por ejemplo, una ventana sin el marco del sistema de ventanas, debes utilizar indicadores especiales.

QWidget tiene muchas funciones miembro, pero algunas de ellas tienen poca funcionalidad directa; por ejemplo, QWidget tiene una propiedad de fuente, pero nunca la utiliza por sí mismo. Hay muchas subclases que proporcionan funcionalidad real, como QLabel, QPushButton, QListWidget y QTabWidget.

Widgets de nivel superior e hijos

Un widget sin un widget padre es siempre una ventana independiente (widget de nivel superior). Para estos widgets, setWindowTitle() y setWindowIcon() establecen la barra de título y el icono, respectivamente.

Los widgets que no son ventanas son widgets hijos, que se muestran dentro de sus widgets padres. La mayoría de los widgets de Qt resultan útiles principalmente como widgets hijos. Por ejemplo, es posible mostrar un botón como una ventana de nivel superior, pero la mayoría de los usuarios prefieren colocar sus botones dentro de otros widgets, como QDialog.

Widget de citas con widgets secundarios etiquetados

Un widget padre que contiene varios widgets hijos.

El diagrama anterior muestra un widget ` QGroupBox ` que se utiliza para contener varios widgets hijos en un diseño proporcionado por ` QGridLayout`. Los widgets hijos ` QLabel ` se han resaltado para indicar sus tamaños completos.

Si deseas utilizar un QWidget para contener widgets hijos, normalmente querrás añadir un diseño al QWidget padre. Consulta «Gestión de diseños» para obtener más información.

Widgets compuestos

Cuando un widget se utiliza como contenedor para agrupar varios widgets hijos, se denomina widget compuesto. Estos pueden crearse construyendo un widget con las propiedades visuales necesarias —por ejemplo, un QFrame — y añadiéndole widgets hijos, que suelen gestionarse mediante un diseño.

Los widgets compuestos también pueden crearse creando una subclase de un widget estándar, como QWidget o QFrame, y añadiendo el diseño y los widgets hijos necesarios en el constructor de la subclase. Muchos de los ejemplos que se incluyen con Qt utilizan este enfoque, y también se trata en el Tutorial de Qt Widgets.

Widgets personalizados y dibujo

Dado que QWidget es una subclase de QPaintDevice, las subclases pueden utilizarse para mostrar contenido personalizado que se compone mediante una serie de operaciones de dibujo con una instancia de la clase QPainter. Este enfoque contrasta con el enfoque de tipo «lienzo» utilizado por el Graphics View Framework, en el que la aplicación añade elementos a una escena y el propio marco se encarga de renderizarlos.

Cada widget realiza todas las operaciones de dibujo desde su función paintEvent(). Esta se invoca cada vez que es necesario redibujar el widget, ya sea debido a algún cambio externo o a petición de la aplicación.

El ejemplo del reloj analógico muestra cómo un widget sencillo puede gestionar los eventos de pintura.

Indicaciones de tamaño y políticas de tamaño

Al implementar un nuevo widget, casi siempre resulta útil reimplementar ` sizeHint()` para proporcionar un tamaño predeterminado razonable para el widget y establecer la política de tamaño correcta con ` setSizePolicy()`.

Por defecto, los widgets compuestos que no proporcionen una indicación de tamaño se dimensionarán según los requisitos de espacio de sus widgets hijos.

La política de tamaño te permite proporcionar un buen comportamiento predeterminado para el sistema de gestión de maquetación, de modo que otros widgets puedan contener y gestionar el tuyo fácilmente. La política de tamaño predeterminada indica que la sugerencia de tamaño representa el tamaño preferido del widget, lo cual suele ser suficiente para muchos widgets.

Nota: El tamaño de los widgets de nivel superior está limitado a 2/3 de la altura y la anchura del escritorio. Puedes ajustar manualmente el tamaño del widget con la función ` resize()` si estos límites resultan insuficientes.

Eventos

Los widgets responden a eventos que suelen estar provocados por acciones del usuario. Qt envía eventos a los widgets llamando a funciones específicas de gestión de eventos con instancias de subclases de ` QEvent ` que contienen información sobre cada evento.

Si tu widget solo contiene widgets hijos, probablemente no necesites implementar ningún controlador de eventos. Si deseas detectar un clic del ratón en un widget hijo, llama a la función ` underMouse()` del hijo dentro de la función ` mousePressEvent()` del widget.

El ejemplo «Scribble» implementa un conjunto más amplio de eventos para gestionar el movimiento del ratón, las pulsaciones de botones y el cambio de tamaño de la ventana.

Tendrás que definir el comportamiento y el contenido de tus propios widgets, pero a continuación te ofrecemos una breve descripción de los eventos relevantes para QWidget, empezando por los más comunes:

  • paintEvent() se invoca cada vez que es necesario volver a dibujar el widget. Todo widget que muestre contenido personalizado debe implementarlo. El dibujo mediante un ` QPainter ` solo puede realizarse en una función ` paintEvent()` o en una función llamada por ` paintEvent()`.
  • resizeEvent() se invoca cuando se ha cambiado el tamaño del widget.
  • mousePressEvent() se invoca cuando se pulsa un botón del ratón mientras el cursor se encuentra dentro del widget, o cuando el widget ha capturado el ratón mediante grabMouse(). Pulsar el ratón sin soltarlo equivale, en la práctica, a invocar grabMouse().
  • mouseReleaseEvent() se invoca cuando se suelta un botón del ratón. Un widget recibe eventos de suelta del ratón cuando ha recibido el evento de pulsación del ratón correspondiente. Esto significa que si el usuario pulsa el ratón dentro de tu widget y, a continuación, arrastra el ratón a otro lugar antes de soltar el botón, tu widget recibirá el evento de suelta. Hay una excepción: si aparece un menú emergente mientras se mantiene pulsado el botón del ratón, este menú se apropia inmediatamente de los eventos del ratón.
  • mouseDoubleClickEvent() se invoca cuando el usuario hace doble clic en el widget. Si el usuario hace doble clic, el widget recibe un evento de pulsación del ratón, un evento de liberación del ratón (un evento de clic del ratón), una segunda pulsación del ratón, este evento y, finalmente, un segundo evento de liberación del ratón. (También pueden recibirse algunos eventos de movimiento del ratón si este no se mantiene firme durante esta operación.) No es posible distinguir un clic de un doble clic hasta que se produce el segundo clic. (Esta es una de las razones por las que la mayoría de los libros sobre interfaces gráficas de usuario recomiendan que los dobles clics sean una extensión de los clics simples, en lugar de desencadenar una acción diferente.)

Los widgets que aceptan entradas de teclado deben reimplementar algunos controladores de eventos más:

  • keyPressEvent() se invoca cada vez que se pulsa una tecla, y de nuevo cuando una tecla se ha mantenido pulsada el tiempo suficiente para que se repita automáticamente. Las teclas « Tab » y « Shift+Tab » solo se pasan al widget si no son utilizadas por los mecanismos de cambio de foco. Para forzar que esas teclas sean procesadas por tu widget, debes reimplementar QWidget::event().
  • focusInEvent() se invoca cuando el widget obtiene el foco del teclado (suponiendo que hayas llamado a setFocusPolicy()). Los widgets que se comportan correctamente indican que tienen el foco del teclado de una forma clara pero discreta.
  • focusOutEvent() se invoca cuando el widget pierde el foco del teclado.

Es posible que también tengas que reimplementar algunos de los controladores de eventos menos habituales:

  • mouseMoveEvent() se invoca cada vez que el ratón se mueve mientras se mantiene pulsado un botón. Esto puede resultar útil durante operaciones de arrastrar y soltar. Si llamas a setMouseTracking(true), recibirás eventos de movimiento del ratón incluso cuando no se mantenga pulsado ningún botón. (Consulta también la guía de arrastrar y soltar.)
  • keyReleaseEvent() se invoca cada vez que se suelta una tecla y mientras se mantiene pulsada (si la tecla tiene repetición automática). En ese caso, el widget recibirá un par de eventos de suelta y pulsación de tecla por cada repetición. Las teclas ` Tab ` y ` Shift+Tab ` solo se pasan al widget si no las utilizan los mecanismos de cambio de foco. Para forzar que tu widget procese esas teclas, debes reimplementar ` QWidget::event()`.
  • wheelEvent() se invoca cada vez que el usuario gira la rueda del ratón mientras el widget tiene el foco.
  • enterEvent() se invoca cuando el ratón entra en el espacio de pantalla del widget. (Esto excluye el espacio de pantalla que ocupan los hijos del widget.)
  • leaveEvent() se invoca cuando el ratón sale del espacio de pantalla del widget. Si el ratón entra en un widget hijo, no provocará una llamada a ` leaveEvent()`.
  • moveEvent() se invoca cuando el widget se ha desplazado con respecto a su padre.
  • closeEvent() se invoca cuando el usuario cierra el widget (o cuando se invoca close()).

También hay algunos eventos bastante poco conocidos descritos en la documentación de QEvent::Type. Para gestionar estos eventos, es necesario reimplementar event() directamente.

La implementación predeterminada de event() gestiona Tab y Shift+Tab (para desplazar el foco del teclado) y reenvía la mayoría de los demás eventos a uno de los controladores más especializados mencionados anteriormente.

Los eventos y el mecanismo utilizado para transmitirlos se tratan en «El sistema de eventos».

Grupos de funciones y propiedades

ContextoFunciones y propiedades
Funciones de ventanashow(), hide(), raise(), lower(), close().
Ventanas de nivel superiorwindowModified, windowTitle, windowIcon, isActiveWindow, activateWindow(), minimized, showMinimized(), maximized, showMaximized(), fullScreen, showFullScreen(), showNormal().
Contenido de la ventanaupdate(), repaint(), scroll().
Geometríapos, x(), y(), rect, size, width(), height(), move(), resize(), sizePolicy, sizeHint(), minimumSizeHint(), updateGeometry(), layout(), frameGeometry, geometry, childrenRect, childrenRegion, adjustSize(), mapFromGlobal(), mapToGlobal(), mapFromParent(), mapToParent(), maximumSize, minimumSize, sizeIncrement, baseSize, setFixedSize()
Modovisible, isVisibleTo(), enabled, isEnabledTo(), modal, isWindow(), mouseTracking, updatesEnabled, visibleRegion().
Aspecto y funcionamientostyle(), setStyle(), styleSheet, cursor, font, palette, backgroundRole(), setBackgroundRole(), fontInfo(), fontMetrics().
Funciones de foco del tecladofocus, focusPolicy, setFocus(), clearFocus(), setTabOrder(), setFocusProxy(), focusNextChild(), focusPreviousChild().
Captura del ratón y del tecladograbMouse(), releaseMouse(), grabKeyboard(), releaseKeyboard(), mouseGrabber(), keyboardGrabber().
Manejadores de eventosevent(), mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), keyPressEvent(), keyReleaseEvent(), focusInEvent(), focusOutEvent(), wheelEvent(), enterEvent(), leaveEvent(), paintEvent(), moveEvent(), resizeEvent(), closeEvent(), dragEnterEvent(), dragMoveEvent(), dragLeaveEvent(), dropEvent(), childEvent(), showEvent(), hideEvent(), customEvent(). changeEvent(),
Funciones del sistemaparentWidget(), window(), setParent(), winId(), find(), metric().
Menú contextualcontextMenuPolicy, contextMenuEvent(), customContextMenuRequested(), actions()
Ayuda interactivasetToolTip(), setWhatsThis()

Hojas de estilo de widgets

Además de los estilos de widget estándar para cada plataforma, los widgets también pueden personalizarse según las reglas especificadas en una hoja de estilo de widget ( style sheet). Esta característica permite personalizar el aspecto de widgets específicos para proporcionar indicaciones visuales a los usuarios sobre su finalidad. Por ejemplo, se podría aplicar un estilo concreto a un botón para indicar que realiza una acción destructiva.

El uso de las hojas de estilo de los widgets se describe con más detalle en el documento Hojas de estilo de Qt.

Transparencia y doble búfer

QWidget aplica automáticamente el doble búfer a su dibujo, por lo que no es necesario escribir código de doble búfer en ` paintEvent()` para evitar el parpadeo.

El contenido de los widgets padres se propaga por defecto a cada uno de sus hijos siempre que no se haya establecido Qt::WA_PaintOnScreen. Se pueden crear widgets personalizados que aprovechen esta característica actualizando regiones irregulares (para crear widgets hijos no rectangulares) o dibujando con colores que no tengan el componente alfa al máximo. El siguiente diagrama muestra cómo se pueden ajustar los atributos y propiedades de un widget personalizado para conseguir diferentes efectos.

Tres imágenes de una casa con diferentes propiedades de fondo: transparente, rellena de blanco y sin inicializar

En el diagrama anterior, se construye un widget hijo rectangular semitransparente al que se le ha eliminado una zona y se añade a un widget padre (un ` QLabel ` que muestra un mapa de píxeles). A continuación, se configuran diferentes propiedades y atributos del widget para lograr distintos efectos:

  • El widget de la izquierda no tiene configuradas propiedades ni atributos adicionales. Este estado predeterminado se adapta a la mayoría de los widgets personalizados que tienen transparencia, tienen formas irregulares o no se pintan en toda su superficie con un pincel opaco.
  • El widget del centro tiene configurada la propiedad « autoFillBackground ». Esta propiedad se utiliza con widgets personalizados que dependen del propio widget para proporcionar un fondo por defecto y que no pintan toda su superficie con un pincel opaco.
  • El widget de la derecha tiene configurado el atributo Qt::WA_OpaquePaintEvent. Esto indica que el widget pintará toda su superficie con colores opacos. La superficie del widget estará inicialmente sin inicializar, lo que se representa en el diagrama con un patrón de cuadrícula diagonal roja que se trasluce a través de la zona pintada.

Para actualizar rápidamente widgets personalizados con colores de fondo sencillos, como los widgets de trazado o gráficos en tiempo real, es mejor definir un color de fondo adecuado (utilizando ` setBackgroundRole()` con la función ` QPalette::Window `), establecer la propiedad ` autoFillBackground ` e implementar únicamente la funcionalidad de dibujo necesaria en el método ` paintEvent()` del widget.

Para actualizar rápidamente widgets personalizados que se redibujan constantemente en toda su superficie con contenido opaco —por ejemplo, widgets de streaming de vídeo—, es mejor establecer la propiedad ` Qt::WA_OpaquePaintEvent` del widget, evitando así cualquier sobrecarga innecesaria asociada al redibujado del fondo del widget.

Si un widget tiene configurados tanto el atributo Qt::WA_OpaquePaintEvent como la propiedad autoFillBackground, el atributo Qt::WA_OpaquePaintEvent tiene prioridad. Dependiendo de tus necesidades, debes elegir uno de ellos.

El contenido de los widgets padres también se propaga a los Qt Widgets estándar. Esto puede dar lugar a algunos resultados inesperados si el widget padre está decorado de forma no estándar, tal y como se muestra en el diagrama siguiente.

Un widget tiene el fondo transparente y el otro tiene el fondo relleno.

El margen para personalizar el comportamiento de dibujo de los widgets estándar de Qt, sin recurrir a la subclasificación, es ligeramente menor que el que ofrecen los widgets personalizados. Por lo general, la apariencia deseada de un widget estándar se puede conseguir configurando su propiedad « autoFillBackground ».

Creación de ventanas translúcidas

Se pueden crear ventanas con regiones translúcidas en sistemas de ventanas que admitan composición.

Para habilitar esta característica en un widget de nivel superior, configura su atributo « Qt::WA_TranslucentBackground » con ` setAttribute()` y asegúrate de que su fondo se pinte con colores no opacos en las regiones que desees que sean parcialmente transparentes.

Notas sobre la plataforma:

  • X11: Esta función requiere el uso de un servidor X que admita elementos visuales ARGB y un gestor de ventanas con composición.
  • Windows: Para que la translucidez funcione, el widget debe tener activada la bandera de ventana « Qt::FramelessWindowHint ».
  • macOS: El widget debe tener activado el indicador de ventana « Qt::FramelessWindowHint » para que la translucidez funcione.

Widgets nativos frente a widgets «aliens»

Los widgets «externos» son widgets desconocidos para el sistema de ventanas. No tienen asociado ningún identificador de ventana nativo. Esta característica acelera significativamente el dibujo y el redimensionamiento de los widgets, y elimina el parpadeo.

Si necesitas el comportamiento anterior con ventanas nativas, elige una de las siguientes opciones:

  1. Utiliza el ` QT_USE_NATIVE_WINDOWS=1 ` en tu entorno.
  2. Establece el atributo « Qt::AA_NativeWindows » en tu aplicación. Todos los widgets serán widgets nativos.
  3. Establezca el atributo « Qt::WA_NativeWindow » en los widgets: el propio widget y todos sus antecesores pasarán a ser nativos (a menos que se haya establecido « Qt::WA_DontCreateNativeAncestors »).
  4. Llama a ` QWidget::winId ` para forzar una ventana nativa (esto implica el punto 3).
  5. Establece el atributo ` Qt::WA_PaintOnScreen ` para forzar una ventana nativa (esto implica el punto 3).

Véase también QEvent, QPainter, QGridLayout y QBoxLayout.

Documentación sobre los tipos de miembros

enum QWidget::RenderFlag
flags QWidget::RenderFlags

Esta enumeración describe cómo se representa el widget al llamar a la función ` QWidget::render()`.

ConstanteValorDescripción
QWidget::DrawWindowBackground0x1Si se habilita esta opción, el fondo del widget se representa en el destino aunque no esté definido autoFillBackground. Por defecto, esta opción está habilitada.
QWidget::DrawChildren0x2Si se habilita esta opción, los elementos secundarios del widget se representan de forma recursiva en el destino. De forma predeterminada, esta opción está habilitada.
QWidget::IgnoreMask0x4Si se habilita esta opción, se ignora la función ` QWidget::mask()` del widget al renderizar en el destino. Por defecto, esta opción está deshabilitada.

El tipo RenderFlags es un typedef para QFlags<RenderFlag>. Almacena una combinación OR de valores de RenderFlag.

Documentación de la propiedad

acceptDrops : bool

Esta propiedad indica si los eventos de arrastre están habilitados para este widget

Al establecer esta propiedad en «true», se indica al sistema que este widget puede aceptar eventos de soltar.

Advertencia: No modifiques esta propiedad en un controlador de eventos de arrastrar y soltar.

Por defecto, esta propiedad tiene el valor « false ».

Funciones de acceso:

bool acceptDrops() const
void setAcceptDrops(bool on)

Véase también «Arrastrar y soltar».

accessibleDescription : QString

Esta propiedad contiene la descripción del widget tal y como la ven las tecnologías de asistencia

La descripción accesible de un widget debe transmitir lo que hace dicho widget. Si bien el « accessibleName » debe ser una cadena corta y concisa (por ejemplo, «Guardar»), la descripción debe aportar más contexto, como «Guarda el documento actual».

Esta propiedad debe estar localizada.

Por defecto, esta propiedad contiene una cadena vacía y Qt recurre a la información de ayuda para proporcionar esta información.

Funciones de acceso:

QString accessibleDescription() const
void setAccessibleDescription(const QString &description)

Véase también QWidget::accessibleName y QAccessibleInterface::text().

[since 6.9] accessibleIdentifier : QString

Esta propiedad contiene el identificador del widget tal y como lo perciben las tecnologías de asistencia

Si se establece, las tecnologías de asistencia pueden utilizar el identificador accesible de un widget para identificar un widget específico, por ejemplo, en pruebas automatizadas.

Esta enumeración se introdujo en Qt 6.9.

Funciones de acceso:

QString accessibleIdentifier() const
void setAccessibleIdentifier(const QString &identifier)

accessibleName : QString

Esta propiedad contiene el nombre del widget tal y como lo perciben las tecnologías de apoyo

Este es el nombre principal con el que las tecnologías de asistencia, como los lectores de pantalla, anuncian este widget. Para la mayoría de los widgets no es necesario configurar esta propiedad. Por ejemplo, en el caso de QPushButton se utilizará el texto del botón.

Es importante configurar esta propiedad cuando el widget no proporcione ningún texto. Por ejemplo, un botón que solo contenga un icono debe configurar esta propiedad para que funcione con los lectores de pantalla. El nombre debe ser breve y equivalente a la información visual que transmite el widget.

Esta propiedad debe estar localizada.

Por defecto, esta propiedad contiene una cadena vacía.

Funciones de acceso:

QString accessibleName() const
void setAccessibleName(const QString &name)

Véase también QWidget::accessibleDescription y QAccessibleInterface::text().

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 evento de pintura. El color utilizado viene definido por el rol de color « QPalette::Window » de la propiedad « 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.

Esta propiedad no se puede desactivar (es decir, establecer en «false») si el padre de un widget tiene un degradado estático como fondo.

Advertencia: Utiliza esta propiedad con precaución junto con las hojas de estilo de Qt. Cuando un widget tiene una hoja de estilo con un fondo válido o una imagen de borde, esta propiedad se desactiva automáticamente.

Por defecto, esta propiedad es « false ».

Funciones de acceso:

bool autoFillBackground() const
void setAutoFillBackground(bool enabled)

Véase también Qt::WA_OpaquePaintEvent, Qt::WA_NoSystemBackground y Transparency and Double Buffering.

baseSize : QSize

Esta propiedad contiene el tamaño base del widget

El tamaño base se utiliza para calcular el tamaño adecuado del widget si este define la función ` sizeIncrement()`.

Por defecto, en un widget recién creado, esta propiedad contiene un tamaño con anchura y altura iguales a cero.

Funciones de acceso:

QSize baseSize() const
void setBaseSize(const QSize &)
void setBaseSize(int basew, int baseh)

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

[read-only] childrenRect : QRect

Esta propiedad contiene el rectángulo delimitador de los elementos hijos del widget

Se excluyen los elementos hijos ocultos.

Por defecto, para un widget sin elementos hijos, esta propiedad contiene un rectángulo de anchura y altura cero situado en el origen.

Funciones de acceso:

QRect childrenRect() const

Véase también childrenRegion() y geometry().

[read-only] childrenRegion : QRegion

Esta propiedad contiene la superficie total ocupada por los elementos secundarios del widget

Se excluyen los elementos hijos ocultos.

Por defecto, en el caso de un widget sin elementos hijos, esta propiedad contiene una región vacía.

Funciones de acceso:

QRegion childrenRegion() const

Véase también childrenRect(), geometry() y mask().

contextMenuPolicy : Qt::ContextMenuPolicy

cómo muestra el widget un menú contextual

El valor por defecto de esta propiedad es « Qt::DefaultContextMenu », lo que significa que se invoca el controlador « contextMenuEvent()». Otros valores son « Qt::NoContextMenu », « Qt::PreventContextMenu », « Qt::ActionsContextMenu » y « Qt::CustomContextMenu ». Con « Qt::CustomContextMenu », se emite la señal « customContextMenuRequested()».

Funciones de acceso:

Qt::ContextMenuPolicy contextMenuPolicy() const
void setContextMenuPolicy(Qt::ContextMenuPolicy policy)

Véase también contextMenuEvent(), customContextMenuRequested() y actions().

cursor : QCursor

Esta propiedad define la forma del cursor para este widget

El cursor del ratón adoptará esta forma cuando se sitúe sobre este widget. Consulta la guía « list of predefined cursor objects » para ver una selección de formas útiles.

Un widget de edición podría utilizar un cursor en forma de «I»:

setCursor(Qt::IBeamCursor);

Si no se ha establecido ningún cursor, o tras llamar a unsetCursor(), se utiliza el cursor del elemento padre.

Por defecto, esta propiedad contiene un cursor con la forma Qt::ArrowCursor.

Algunas implementaciones de ventana subyacentes restablecerán el cursor si este sale de un widget, incluso si el ratón está bloqueado. Si desea que haya un cursor establecido para todos los widgets, incluso cuando estén fuera de la ventana, considere utilizar QGuiApplication::setOverrideCursor().

Funciones de acceso:

QCursor cursor() const
void setCursor(const QCursor &)
void unsetCursor()

Véase también ` QGuiApplication::setOverrideCursor()`.

enabled : bool

Esta propiedad indica si el widget está activado

En general, un widget habilitado gestiona los eventos del teclado y del ratón; uno deshabilitado, no. Se hace una excepción con QAbstractButton.

Algunos widgets se muestran de forma diferente cuando están desactivados. Por ejemplo, un botón puede mostrar su etiqueta en gris. Si tu widget necesita saber cuándo se activa o se desactiva, puedes utilizar la función ` changeEvent()` con el tipo ` QEvent::EnabledChange`.

Al desactivar un widget, se desactivan implícitamente todos sus hijos. Al activarlo, se activan a su vez todos los widgets hijos, a menos que se hayan desactivado explícitamente. No es posible activar explícitamente un widget hijo que no sea una ventana mientras su widget padre permanezca desactivado.

Por defecto, esta propiedad es ` true`.

Funciones de acceso:

bool isEnabled() const
void setEnabled(bool)

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

[read-only] focus : bool

Esta propiedad indica si este widget (o su proxy de foco) tiene el foco de entrada del teclado

Por defecto, esta propiedad es false.

Nota: Obtener el valor de esta propiedad para un widget equivale, en la práctica, a comprobar si QApplication::focusWidget() hace referencia al widget.

Funciones de acceso:

bool hasFocus() const

Véase también setFocus(), clearFocus(), setFocusPolicy() y QApplication::focusWidget().

focusPolicy : Qt::FocusPolicy

Esta propiedad define la forma en que el widget acepta el foco del teclado

La política 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 ambos, y « Qt::NoFocus » (el valor por defecto) si no acepta el foco en absoluto.

Debes habilitar el foco del teclado para un widget si este procesa eventos de teclado. Normalmente, esto se hace desde el constructor del widget. Por ejemplo, el constructor QLineEdit llama a setFocusPolicy(Qt::StrongFocus).

Si el widget tiene un proxy de foco, la política de foco se le propagará.

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 configurada actualmente para el widget

Esta propiedad describe la fuente solicitada por el widget. La fuente es utilizada por el estilo del widget al renderizar componentes estándar, y está disponible como medio para garantizar que los widgets personalizados puedan mantener la coherencia con el aspecto y el comportamiento de la plataforma nativa. Es habitual que diferentes plataformas, o diferentes estilos, definan fuentes distintas para una aplicación.

Al asignar una nueva fuente a un widget, las propiedades de esta fuente se combinan con la fuente predeterminada del widget para formar la fuente final del widget. Puedes llamar a fontInfo() para obtener una copia de la fuente final del widget. La fuente final también se utiliza para inicializar la fuente de QPainter.

El valor por defecto depende del entorno del sistema. QApplication mantiene una fuente del sistema o del tema que sirve como valor por defecto para todos los widgets. También puede haber fuentes predeterminadas especiales para determinados tipos de widgets. Además, puedes definir tú mismo las fuentes predeterminadas para los widgets pasando una fuente personalizada y el nombre de un widget a QApplication::setFont(). Por último, la fuente se compara con la base de datos de fuentes de Qt para encontrar la que mejor se ajuste.

QWidget propaga las propiedades explícitas de la fuente de padre a hijo. Si se modifica una propiedad específica de una fuente y se asigna esa fuente a un widget, dicha propiedad se propagará a todos los hijos del widget, anulando cualquier valor predeterminado del sistema para esa propiedad. Tenga en cuenta que, por defecto, las fuentes no se propagan a las ventanas (véase isWindow()) a menos que se habilite el atributo Qt::WA_WindowPropagation.

QWidgetLa propagación de fuentes es similar a la propagación de paletas.

El estilo actual, que se utiliza para representar el contenido de todos los Qt Widgets, puede optar por utilizar la fuente del widget o, en algunos casos, ignorarla (parcial o totalmente). En concreto, ciertos estilos, como el estilo GTK, el estilo Mac y el estilo Windows Vista, aplican modificaciones especiales a la fuente del widget para que se adapte al aspecto y comportamiento nativos de la plataforma. Por este motivo, no se garantiza que la asignación de propiedades a la fuente de un widget cambie la apariencia del mismo. En su lugar, puedes optar por aplicar una hoja de estilo.

Nota: Si se utilizan hojas de estilo de Qt en el mismo widget que setFont(), las hojas de estilo tendrán prioridad en caso de conflicto entre los ajustes.

Funciones de acceso:

const QFont &font() const
void setFont(const QFont &)

Véase también fontInfo() y fontMetrics().

[read-only] frameGeometry : QRect

geometría del widget con respecto a su elemento padre, incluido cualquier marco de ventana

Consulte la documentación sobre la geometría de las ventanas para obtener una visión general de los aspectos relacionados con la geometría de las ventanas.

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Funciones de acceso:

QRect frameGeometry() const

Véanse también geometry(), x(), y() y pos().

[read-only] frameSize : QSize

Esta propiedad contiene el tamaño del widget, incluido el marco de la ventana

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Funciones de acceso:

QSize frameSize() const

[read-only] fullScreen : bool

Esta propiedad se mantiene independientemente de si el widget se muestra en modo de pantalla completa

Un widget en modo de pantalla completa ocupa toda el área de la pantalla y no muestra elementos decorativos de la ventana, como la barra de título.

Por defecto, esta propiedad es « false ».

Funciones de acceso:

bool isFullScreen() const

Véase también windowState(), minimized y maximized.

geometry : QRect

Esta propiedad contiene la geometría del widget en relación con su elemento padre, sin incluir el marco de la ventana

Si el widget es un widget de nivel superior (una ventana), su geometría se expresa en coordenadas globales de pantalla.

Al cambiar la geometría, el widget, si está visible, recibe inmediatamente un evento de desplazamiento (moveEvent()) y/o un evento de redimensionamiento (resizeEvent()). Si el widget no está visible en ese momento, se garantiza que recibirá los eventos correspondientes antes de que se muestre.

El componente de tamaño se ajusta si se encuentra fuera del rango definido por minimumSize() y maximumSize().

Advertencia: Llamar a setGeometry() dentro de resizeEvent() o moveEvent() puede provocar una recursión infinita.

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los problemas de geometría relacionados con las ventanas.

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Funciones de acceso:

const QRect &geometry() const
void setGeometry(int x, int y, int w, int h)
void setGeometry(const QRect &)

Véase también frameGeometry(), rect(), move(), resize(), moveEvent(), resizeEvent(), minimumSize() y maximumSize().

[read-only] height : int

Esta propiedad contiene la altura del widget, sin incluir el marco de la ventana

Consulte la documentación sobre geometría de ventanas para obtener una visión general de las cuestiones relacionadas con la geometría de las ventanas.

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de ` screen geometry`.

Funciones de acceso:

int height() const

Véanse también geometry, width y size.

inputMethodHints : Qt::InputMethodHints

Qué sugerencias específicas del método de entrada tiene el widget.

Esto solo es relevante para los widgets de entrada. El método de entrada lo utiliza para obtener indicaciones sobre cómo debe funcionar. Por ejemplo, si se establece el indicador « Qt::ImhFormattedNumbersOnly », el método de entrada puede modificar sus componentes visuales para reflejar que solo se pueden introducir números.

Advertencia: Algunos widgets requieren determinadas opciones para funcionar según lo previsto. Para establecer una opción, utiliza « w->setInputMethodHints(w->inputMethodHints()|f) » en lugar de « w->setInputMethodHints(f) ».

Nota: Los indicadores son solo sugerencias, por lo que la implementación concreta del método de entrada es libre de ignorarlos. Si desea asegurarse de que se introduzcan determinados tipos de caracteres, también debe establecer un indicador ` QValidator ` en el widget.

El valor por defecto es Qt::ImhNone.

Funciones de acceso:

Qt::InputMethodHints inputMethodHints() const
void setInputMethodHints(Qt::InputMethodHints hints)

Véase también inputMethodQuery().

[read-only] isActiveWindow : bool

Esta propiedad indica si la ventana de este widget es la ventana activa

La ventana activa es aquella que contiene el widget que tiene el foco del teclado (la ventana puede seguir teniendo el foco aunque no contenga widgets o ninguno de sus widgets acepte el foco del teclado).

Cuando hay ventanas emergentes visibles, esta propiedad es « true » tanto para la ventana activa como para la ventana emergente.

Por defecto, esta propiedad es « false ».

Funciones de acceso:

bool isActiveWindow() const

Véase también ` activateWindow()` y ` QApplication::activeWindow()`.

layoutDirection : Qt::LayoutDirection

Esta propiedad determina la dirección de disposición de este widget.

Nota: Desde Qt 4.7,este método ya no afecta a la dirección de maquetación del texto.

Por defecto, esta propiedad está establecida en « Qt::LeftToRight ».

Cuando se establece la dirección de diseño en un widget, esta se propaga a los hijos del widget, pero no a los hijos que sean ventanas ni a aquellos para los que se haya llamado explícitamente a setLayoutDirection(). Además, los widgets hijos añadidos después de que se haya llamado a setLayoutDirection() para el padre no heredan la dirección de maquetación del padre.

Funciones de acceso:

Qt::LayoutDirection layoutDirection() const
void setLayoutDirection(Qt::LayoutDirection direction)
void unsetLayoutDirection()

Véase también QApplication::layoutDirection.

locale : QLocale

Esta propiedad contiene la configuración regional del widget

Siempre que no se haya establecido ninguna configuración regional específica, será la configuración regional del elemento padre o (si este widget es de nivel superior) la configuración regional por defecto.

Si el widget muestra fechas o números, estos deben formatearse utilizando la configuración regional del widget.

Funciones de acceso:

QLocale locale() const
void setLocale(const QLocale &locale)
void unsetLocale()

Véase también QLocale y QLocale::setDefault().

[read-only] maximized : bool

Esta propiedad se mantiene independientemente de si este widget está maximizado

Esta propiedad solo es relevante para ventanas.

Nota: Debido a las limitaciones de algunos sistemas de ventanas, esto no siempre ofrece los resultados esperados (por ejemplo, si el usuario en X11 maximiza la ventana a través del gestor de ventanas, Qt no tiene forma de distinguir esto de cualquier otro cambio de tamaño). Se espera que esto mejore a medida que evolucionen los protocolos de los gestores de ventanas.

Por defecto, esta propiedad es « false ».

Funciones de acceso:

bool isMaximized() const

Véase también windowState(), showMaximized(), visible, show(), hide(), showNormal() y minimized.

maximumHeight : int

Esta propiedad contiene la altura máxima del widget en píxeles

Esta propiedad se corresponde con la altura que contiene la propiedad « maximumSize ».

Por defecto, esta propiedad tiene un valor de 16777215.

Nota: La definición de la macro « QWIDGETSIZE_MAX » limita el tamaño máximo de los widgets.

Funciones de acceso:

int maximumHeight() const
void setMaximumHeight(int maxh)

Véase también « maximumSize » y « maximumWidth ».

maximumSize : QSize

Esta propiedad indica el tamaño máximo del widget en píxeles

El widget no se puede ampliar a un tamaño superior al tamaño máximo del widget.

Por defecto, esta propiedad contiene un tamaño en el que tanto el ancho como la altura tienen valores de 16777215.

Nota: La definición de la macro « QWIDGETSIZE_MAX » limita el tamaño máximo de los widgets.

Funciones de acceso:

QSize maximumSize() const
void setMaximumSize(const QSize &)
void setMaximumSize(int maxw, int maxh)

Véase también maximumWidth, maximumHeight, minimumSize y sizeIncrement.

maximumWidth : int

Esta propiedad contiene el ancho máximo del widget en píxeles

Esta propiedad se corresponde con el ancho que contiene la propiedad « maximumSize ».

Por defecto, esta propiedad tiene un valor de 16777215.

Nota: La definición de la macro « QWIDGETSIZE_MAX » limita el tamaño máximo de los widgets.

Funciones de acceso:

int maximumWidth() const
void setMaximumWidth(int maxw)

Véase también « maximumSize » y « maximumHeight ».

[read-only] minimized : bool

Esta propiedad se mantiene independientemente de si este widget está minimizado (en forma de icono)

Esta propiedad solo es relevante para las ventanas.

Por defecto, esta propiedad tiene el valor « false ».

Funciones de acceso:

bool isMinimized() const

Véase también showMinimized(), visible, show(), hide(), showNormal() y maximized.

minimumHeight : int

Esta propiedad contiene la altura mínima del widget en píxeles

Esta propiedad se corresponde con la altura que establece la propiedad « minimumSize ».

Por defecto, esta propiedad tiene un valor de 0.

Funciones de acceso:

int minimumHeight() const
void setMinimumHeight(int minh)

Véase también « minimumSize » y « minimumWidth ».

minimumSize : QSize

Esta propiedad establece el tamaño mínimo del widget

El widget no se puede redimensionar a un tamaño inferior al tamaño mínimo del widget. El tamaño del widget se establece obligatoriamente en el tamaño mínimo si el tamaño actual es inferior.

El tamaño mínimo establecido por esta función anulará el tamaño mínimo definido por QLayout. Para desactivar el tamaño mínimo, utilice el valor QSize(0, 0).

Por defecto, esta propiedad contiene un tamaño con anchura y altura iguales a cero.

Funciones de acceso:

QSize minimumSize() const
void setMinimumSize(const QSize &)
void setMinimumSize(int minw, int minh)

Véase también minimumWidth, minimumHeight, maximumSize y sizeIncrement.

[read-only] minimumSizeHint : QSize

Esta propiedad indica el tamaño mínimo recomendado para el widget

Si el valor de esta propiedad es un tamaño no válido, no se recomienda ningún tamaño mínimo.

La implementación predeterminada de `minimumSizeHint()` devuelve un tamaño no válido si no hay ningún diseño para este widget y, en caso contrario, devuelve el tamaño mínimo del diseño. La mayoría de los widgets integrados reimplementan `minimumSizeHint()`.

QLayout Nunca se redimensionará un widget a un tamaño inferior al tamaño mínimo indicado, a menos que se establezca ` minimumSize()` o que la política de tamaño se establezca en `QSizePolicy::Ignore`. Si se establece ` minimumSize()`, se ignorará el tamaño mínimo indicado.

Funciones de acceso:

virtual QSize minimumSizeHint() const

Véase también QSize::isValid(), resize(), setMinimumSize() y sizePolicy().

minimumWidth : int

Esta propiedad contiene el ancho mínimo del widget en píxeles

Esta propiedad se corresponde con el ancho establecido por la propiedad « minimumSize ».

Por defecto, esta propiedad tiene un valor de 0.

Funciones de acceso:

int minimumWidth() const
void setMinimumWidth(int minw)

Véanse también « minimumSize » y « minimumHeight ».

Esta propiedad indica si el widget es un widget modal

Esta propiedad solo tiene sentido en el caso de las ventanas. Un widget modal impide que los widgets de todas las demás ventanas reciban cualquier entrada.

Por defecto, esta propiedad tiene el valor « false ».

Funciones de acceso:

bool isModal() const

Véase también isWindow(), windowModality y QDialog.

mouseTracking : bool

Esta propiedad indica si el seguimiento del ratón está activado para el widget

Si el seguimiento del ratón está desactivado (valor predeterminado), el widget solo recibe eventos de movimiento del ratón cuando se mantiene pulsado al menos un botón del ratón mientras se mueve el ratón.

Si el seguimiento del ratón está activado, el widget recibe eventos de movimiento del ratón incluso si no se pulsa ningún botón.

Funciones de acceso:

bool hasMouseTracking() const
void setMouseTracking(bool enable)

Véase también mouseMoveEvent().

[read-only] normalGeometry : QRect

Esta propiedad contiene la geometría del widget tal y como aparecerá cuando se muestre como un widget de nivel superior normal (no maximizado ni a pantalla completa).

Si el widget ya se encuentra en este estado, la geometría normal reflejará el valor actual de ` geometry()` del widget.

En el caso de los widgets secundarios, esta propiedad siempre contiene un rectángulo vacío.

Por defecto, esta propiedad contiene un rectángulo vacío.

Funciones de acceso:

QRect normalGeometry() const

Véanse también ` QWidget::windowState()` y ` QWidget::geometry`.

palette : QPalette

Esta propiedad contiene la paleta del widget

Esta propiedad describe la paleta del widget. La paleta es utilizada por el estilo del widget al renderizar componentes estándar, y está disponible como medio para garantizar que los widgets personalizados puedan mantener la coherencia con el aspecto y el comportamiento de la plataforma nativa. Es habitual que diferentes plataformas, o diferentes estilos, tengan paletas distintas.

Cuando se asigna una nueva paleta a un widget, los roles de color de esta paleta se combinan con la paleta predeterminada del widget para formar la paleta final del mismo. La entrada de la paleta correspondiente al rol de fondo del widget se utiliza para rellenar el fondo del widget (véase QWidget::autoFillBackground), y el rol de primer plano inicializa el lápiz de QPainter.

El valor por defecto depende del entorno del sistema. QApplication mantiene una paleta de sistema/tema que sirve como valor por defecto para todos los widgets. También puede haber paletas predeterminadas especiales para ciertos tipos de widgets (por ejemplo, en Windows Vista, todas las clases que derivan de QMenuBar tienen una paleta predeterminada especial). También puedes definir tú mismo paletas predeterminadas para los widgets pasando una paleta personalizada y el nombre de un widget a QApplication::setPalette(). Por último, el estilo siempre tiene la opción de ajustar la paleta tal y como se asigna (véase QStyle::polish()).

QWidget Propaga los roles explícitos de la paleta de padre a hijo. Si asignas un pincel o un color a un rol específico de una paleta y asignas esa paleta a un widget, ese rol se propagará a todos los hijos del widget, anulando cualquier valor predeterminado del sistema para ese rol. Ten en cuenta que, por defecto, las paletas no se propagan a las ventanas (véase isWindow()) a menos que se habilite el atributo « Qt::WA_WindowPropagation ».

QWidgetLa propagación de paletas es similar a la propagación de fuentes.

El estilo actual, que se utiliza para representar el contenido de todos los Qt Widgets estándar, puede elegir libremente colores y pinceles de la paleta del widget o, en algunos casos, ignorar la paleta (parcial o totalmente). En concreto, ciertos estilos, como el estilo GTK, el estilo Mac y el estilo Windows Vista, dependen de API de terceros para renderizar el contenido de los widgets, y estos estilos no suelen seguir la paleta. Por este motivo, no se garantiza que asignar roles a la paleta de un widget cambie la apariencia del mismo. En su lugar, puede optar por aplicar una hoja de estilos.

Advertencia: Noutilices esta función junto con las hojas de estilo de Qt. Al utilizar hojas de estilo, la paleta de un widget se puede personalizar mediante los atributos «color», «color de fondo», «color de selección», «color de fondo de selección» y «color de fondo alternativo».

Funciones de acceso:

const QPalette &palette() const
void setPalette(const QPalette &)

Véase también QGuiApplication::palette(), QWidget::font() y las hojas de estilo de Qt.

pos : QPoint

Esta propiedad indica la posición del widget dentro de su widget padre

Si el widget es una ventana, la posición es la del widget en el escritorio, incluido su marco.

Al cambiar la posición, el widget, si está visible, recibe inmediatamente un evento de desplazamiento (moveEvent()). Si el widget no está visible en ese momento, se garantiza que recibirá un evento antes de que se muestre.

Por defecto, esta propiedad contiene una posición que hace referencia al origen.

Advertencia: Llamar a `move()` o ` setGeometry()` dentro de ` moveEvent()` puede provocar una recursión infinita.

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los problemas de geometría relacionados con las ventanas.

Nota: No todos los sistemas de ventanas admiten la configuración o consulta de las posiciones de las ventanas de nivel superior. En dichos sistemas, el desplazamiento de ventanas mediante programación puede no surtir efecto, y es posible que se devuelvan valores artificiales para las posiciones actuales, como ` QPoint(0, 0)`.

Funciones de acceso:

QPoint pos() const
void move(int x, int y)
void move(const QPoint &)

Véanse también frameGeometry, size, x() y y().

[read-only] rect : QRect

Esta propiedad contiene la geometría interna del widget, excluyendo cualquier marco de ventana

La propiedad «rect» es igual a QRect(0, 0, width(), height()).

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los aspectos relacionados con la geometría de las ventanas.

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Funciones de acceso:

QRect rect() const

Véase también size.

size : QSize

Esta propiedad contiene el tamaño del widget, sin incluir el marco de la ventana

Si el widget está visible cuando se cambia su tamaño, recibe inmediatamente un evento de cambio de tamaño (resizeEvent()). Si el widget no está visible en ese momento, se garantiza que recibirá un evento antes de que se muestre.

El tamaño se ajusta si se encuentra fuera del rango definido por minimumSize() y maximumSize().

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Advertencia: Llamar a resize() o setGeometry() dentro de resizeEvent() puede provocar una recursión infinita.

Nota: Si se establece el tamaño en ` QSize(0, 0) `, el widget no aparecerá en pantalla. Esto también se aplica a las ventanas.

Funciones de acceso:

QSize size() const
void resize(int w, int h)
void resize(const QSize &)

Véase también ` pos`, ` geometry`, ` minimumSize`, ` maximumSize`, ` resizeEvent()` y ` adjustSize()`.

[read-only] sizeHint : QSize

Esta propiedad contiene el tamaño recomendado para el widget

Si el valor de esta propiedad es un tamaño no válido, no se recomienda ningún tamaño.

La implementación predeterminada de sizeHint() devuelve un tamaño no válido si no hay ningún diseño para este widget y, en caso contrario, devuelve el tamaño preferido del diseño.

Funciones de acceso:

virtual QSize sizeHint() const

Véase también QSize::isValid(), minimumSizeHint(), sizePolicy(), setMinimumSize() y updateGeometry().

sizeIncrement : QSize

Esta propiedad almacena el incremento de tamaño del widget

Cuando el usuario cambia el tamaño de la ventana, el tamaño se modificará en pasos de sizeIncrement().width() píxeles en horizontal y sizeIncrement.height() píxeles en vertical, tomando como base baseSize(). Los tamaños preferidos de los widgets corresponden a los enteros no negativos i y j:

width = baseSize().width() + i * sizeIncrement().width();
height = baseSize().height() + j * sizeIncrement().height();

Ten en cuenta que, aunque puedes establecer el incremento de tamaño para todos los widgets, solo afecta a las ventanas.

Por defecto, esta propiedad contiene un tamaño con anchura y altura iguales a cero.

Advertencia: El incremento de tamaño no tiene ningún efecto en Windows, y el gestor de ventanas en X11 puede ignorarlo.

Funciones de acceso:

QSize sizeIncrement() const
void setSizeIncrement(const QSize &)
void setSizeIncrement(int w, int h)

Véase también size, minimumSize y maximumSize.

sizePolicy : QSizePolicy

Esta propiedad define el comportamiento predeterminado del diseño del widget

Si existe un « QLayout » que gestione los elementos hijos de este widget, se utilizará la política de tamaño especificada por dicho diseño. Si no existe dicho « QLayout », se utilizará el resultado de esta función.

La política predeterminada es «Preferred/Preferred», lo que significa que el widget se puede redimensionar libremente, pero prefiere tener el tamaño que devuelve sizeHint(). Los widgets tipo botón establecen la política de tamaño para especificar que pueden estirarse horizontalmente, pero que son fijos verticalmente. Lo mismo se aplica a los controles de edición de línea (como QLineEdit, QSpinBox o un QComboBox editable) y a otros widgets orientados horizontalmente (como QProgressBar). Los QToolButton suelen ser cuadrados, por lo que permiten el crecimiento en ambas direcciones. Los widgets que admiten diferentes orientaciones (como QSlider, QScrollBar o QHeader) especifican el estiramiento únicamente en la dirección correspondiente. Los widgets que pueden proporcionar barras de desplazamiento (normalmente subclases de QScrollArea) suelen especificar que pueden utilizar espacio adicional y que pueden conformarse con menos de sizeHint().

Funciones de acceso:

QSizePolicy sizePolicy() const
void setSizePolicy(QSizePolicy)
void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical)

Véase también sizeHint(), QLayout, QSizePolicy y updateGeometry().

statusTip : QString

Esta propiedad contiene la información de estado del widget

Por defecto, esta propiedad contiene una cadena vacía.

Funciones de acceso:

QString statusTip() const
void setStatusTip(const QString &)

Véase también toolTip y whatsThis.

styleSheet : QString

Esta propiedad contiene la hoja de estilos del widget

La hoja de estilos contiene una descripción textual de las personalizaciones del estilo del widget, tal y como se describe en el documento «Hojas de estilos de Qt Widgets ».

Al establecer una hoja de estilos en un widget, este y sus elementos secundarios utilizan un estilo de hoja de estilos que envuelve el estilo de « style » actual. Para saber cuándo utilizar hojas de estilos, consulta «Enfoques de estilo» en Qt Widgets.

Funciones de acceso:

QString styleSheet() const
void setStyleSheet(const QString &styleSheet)

Véase también ` setStyle()`, ` QApplication::styleSheet`, «Hojas de estilo de Qt» y «Enfoques de estilo para Qt Widgets ».

tabletTracking : bool

Esta propiedad indica si el seguimiento de la tableta está activado para el widget

Si el seguimiento de la tableta está desactivado (por defecto), el widget solo recibe eventos de movimiento de la tableta cuando el lápiz está en contacto con ella, o cuando se pulsa al menos un botón del lápiz, mientras este se está moviendo.

Si el seguimiento de la tableta está activado, el widget recibe eventos de movimiento de la tableta incluso cuando el lápiz se encuentra cerca de ella sin estar en contacto. Esto resulta útil para supervisar la posición, así como propiedades auxiliares como la rotación y la inclinación, y para proporcionar información de retroalimentación en la interfaz de usuario.

Funciones de acceso:

bool hasTabletTracking() const
void setTabletTracking(bool enable)

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

toolTip : QString

Esta propiedad contiene la información de ayuda del widget

Ten en cuenta que, por defecto, las descripciones emergentes solo se muestran para los widgets que son hijos de la ventana activa. Puedes cambiar este comportamiento configurando el atributo Qt::WA_AlwaysShowToolTips en la ventana, no en el widget que contiene la descripción emergente.

Si desea controlar el comportamiento de una información sobre herramientas, puede interceptar la función ` event()` y capturar el evento ` QEvent::ToolTip ` (por ejemplo, si desea personalizar el área en la que debe mostrarse la información sobre herramientas).

Por defecto, esta propiedad contiene una cadena vacía.

Funciones de acceso:

QString toolTip() const
void setToolTip(const QString &)

Véase también QToolTip, statusTip y whatsThis.

toolTipDuration : int

Esta propiedad determina la duración de la información sobre herramientas del widget

Especifica durante cuánto tiempo se mostrará la información sobre herramientas, en milisegundos. Si el valor es -1 (por defecto), la duración se calcula en función de la longitud de la información sobre herramientas.

Funciones de acceso:

int toolTipDuration() const
void setToolTipDuration(int msec)

Véase también toolTip.

updatesEnabled : bool

Esta propiedad se mantiene independientemente de si las actualizaciones están habilitadas

Un widget con las actualizaciones activadas recibe eventos de dibujo y tiene un fondo del sistema; un widget desactivado no. Esto también implica que llamar a update() y repaint() no tiene ningún efecto si las actualizaciones están desactivadas.

Por defecto, esta propiedad es true.

setUpdatesEnabled() se utiliza normalmente para desactivar las actualizaciones durante un breve periodo de tiempo, por ejemplo, para evitar el parpadeo de la pantalla durante cambios importantes. En Qt, los widgets no suelen provocar parpadeos en la pantalla, pero en X11 el servidor puede borrar regiones de la pantalla cuando los widgets se ocultan antes de que puedan ser sustituidos por otros. Desactivar las actualizaciones resuelve este problema.

Ejemplo:

setUpdatesEnabled(false);
bigVisualChanges();
setUpdatesEnabled(true);

Al desactivar un widget, se desactivan implícitamente todos sus hijos. Al activar un widget, se activan todos los widgets hijos, excepto los de nivel superior o aquellos que se hayan desactivado explícitamente. Al volver a activar las actualizaciones, se llama implícitamente a ` update()` en el widget.

Funciones de acceso:

bool updatesEnabled() const
void setUpdatesEnabled(bool enable)

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

visible : bool

Esta propiedad indica si el widget está visible

Al llamar a `setVisible(true)` o a ` show()``, el widget pasa a estar visible si todos sus widgets padres, hasta la ventana, están visibles. Si un antepasado no está visible, el widget no se hará visible hasta que se muestren todos sus antepasados. Si su tamaño o posición han cambiado, Qt garantiza que el widget reciba eventos de desplazamiento y redimensionamiento justo antes de mostrarse. Si el widget aún no se ha redimensionado, Qt ajustará su tamaño a un valor predeterminado adecuado mediante ` adjustSize()`.

Al llamar a `setVisible(false)` o a ` hide()` se oculta un widget de forma explícita. Un widget oculto explícitamente nunca se hará visible, incluso si todos sus antecesores se hacen visibles, a menos que lo muestres.

Un widget recibe eventos de visualización y ocultación cuando cambia su estado de visibilidad. Entre un evento de ocultación y uno de visualización, no es necesario malgastar ciclos de CPU preparando o mostrando información al usuario. Una aplicación de vídeo, por ejemplo, podría simplemente dejar de generar nuevos fotogramas.

Un widget que resulte estar oculto por otras ventanas en la pantalla se considera visible. Lo mismo se aplica a las ventanas minimizadas y a las ventanas que se encuentran en otro escritorio virtual (en plataformas que admitan este concepto). Un widget recibe eventos espontáneos de «show» y «hide» cuando el sistema de ventanas cambia su estado de asignación; por ejemplo, un evento espontáneo de «hide» cuando el usuario minimiza la ventana, y un evento espontáneo de «show» cuando la ventana se restaura de nuevo.

Rara vez es necesario reimplementar la función `setVisible()`. Si necesitas cambiar alguna configuración antes de que se muestre un widget, utiliza en su lugar ` showEvent()`. Si necesitas realizar una inicialización diferida, utiliza el evento «Polish» enviado a la función ` event()`.

Funciones de acceso:

bool isVisible() const
virtual void setVisible(bool visible)

Véase también show(), hide(), isHidden(), isVisibleTo(), isMinimized(), showEvent() y hideEvent().

whatsThis : QString

Esta propiedad contiene el texto de ayuda «¿Qué es esto?» del widget.

Por defecto, esta propiedad contiene una cadena vacía.

Funciones de acceso:

QString whatsThis() const
void setWhatsThis(const QString &)

Véase también QWhatsThis, QWidget::toolTip y QWidget::statusTip.

[read-only] width : int

Esta propiedad contiene el ancho del widget, sin incluir el marco de la ventana

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los aspectos relacionados con la geometría de las ventanas.

Nota: No utilices esta función para averiguar el ancho de una pantalla en un escritorio con varias pantallas. Consulta QScreen para obtener más detalles.

Por defecto, esta propiedad contiene un valor que depende de la plataforma del usuario y de la geometría de la pantalla.

Funciones de acceso:

int width() const

Véase también geometry, height y size.

windowFilePath : QString

Esta propiedad contiene la ruta del archivo asociada a un widget

Esta propiedad solo tiene sentido para ventanas. Asocia una ruta de archivo a una ventana. Si se establece la ruta de archivo, pero no se ha establecido el título de la ventana, Qt establece el título de la ventana con el nombre del archivo de la ruta especificada, obtenido mediante QFileInfo::fileName().

Si se establece el título de la ventana en cualquier momento, este tendrá prioridad y se mostrará en lugar de la cadena de la ruta del archivo.

Además, en macOS, esto tiene la ventaja añadida de que establece el icono de proxy de la ventana, siempre que la ruta de archivo exista.

Si no se ha establecido ninguna ruta de archivo, esta propiedad contiene una cadena vacía.

Por defecto, esta propiedad contiene una cadena vacía.

Funciones de acceso:

QString windowFilePath() const
void setWindowFilePath(const QString &filePath)

Véase también windowTitle y windowIcon.

windowFlags : Qt::WindowFlags

Los indicadores de ventana son una combinación de un tipo (por ejemplo, Qt::Dialog) y cero o más indicaciones para el sistema de ventanas (por ejemplo, Qt::FramelessWindowHint).

Si el widget tenía el tipo Qt::Widget o Qt::SubWindow y se convierte en una ventana (Qt::Window, Qt::Dialog, etc.), se coloca en la posición (0, 0) del escritorio. Si el widget es una ventana y se convierte en un Qt::Widget o Qt::SubWindow, se coloca en la posición (0, 0) con respecto a su widget padre.

Nota: Esta función llama a ` setParent()` al cambiar los indicadores de una ventana, lo que provoca que el widget quede oculto. Debes llamar a ` show()` para que el widget vuelva a ser visible.

Funciones de acceso:

Qt::WindowFlags windowFlags() const
void setWindowFlags(Qt::WindowFlags type)

Véase también windowType(), setWindowFlag() y el ejemplo de indicadores de ventana.

windowIcon : QIcon

Esta propiedad contiene el icono del widget

Esta propiedad solo tiene sentido para ventanas. Si no se ha establecido ningún icono, windowIcon() devuelve el icono de la aplicación (QApplication::windowIcon()).

Nota: En macOS, los iconos de ventana representan el documento activo y no se mostrarán a menos que también se haya establecido una ruta de archivo mediante setWindowFilePath.

Funciones de acceso:

QIcon windowIcon() const
void setWindowIcon(const QIcon &icon)

Señal de notificador:

void windowIconChanged(const QIcon &icon)

Véase también windowTitle y setWindowFilePath.

windowModality : Qt::WindowModality

Esta propiedad indica qué ventanas quedan bloqueadas por el widget modal

Esta propiedad solo tiene sentido para las ventanas. Un widget modal impide que los widgets de otras ventanas reciban entradas. El valor de esta propiedad controla qué ventanas quedan bloqueadas cuando el widget está visible. Cambiar esta propiedad mientras la ventana está visible no tiene ningún efecto; primero debes ocultar el widget con ` hide()` y, a continuación, volver a mostrarlo con ` show()`.

Por defecto, esta propiedad está en estado « Qt::NonModal ».

Funciones de acceso:

Qt::WindowModality windowModality() const
void setWindowModality(Qt::WindowModality windowModality)

Véase también isWindow(), QWidget::modal y QDialog.

windowModified : bool

Esta propiedad indica si el documento que se muestra en la ventana tiene cambios sin guardar

Una ventana modificada es aquella cuyo contenido ha cambiado pero no se ha guardado en el disco. Este indicador tendrá efectos diferentes según la plataforma. En macOS, el botón de cierre tendrá un aspecto diferente; en otras plataformas, el título de la ventana llevará un «*» (asterisco).

El título de la ventana debe contener un marcador de posición «[*]», que indica dónde debe aparecer el «*». Normalmente, debería aparecer justo después del nombre del archivo (por ejemplo, «document1.txt[*] - Editor de texto»). Si la ventana no está modificada, el marcador de posición simplemente se elimina.

Ten en cuenta que, si se marca un widget como modificado, todos sus antecesores también se marcarán como modificados. Sin embargo, si se llama a ` setWindowModified(false) ` en un widget, esto no se propagará a su padre, ya que es posible que otros hijos del padre hayan sido modificados.

Funciones de acceso:

bool isWindowModified() const
void setWindowModified(bool)

Véase también ` windowTitle`.

windowOpacity : double

Esta propiedad define el nivel de opacidad de la ventana.

El rango válido de opacidad va de 1,0 (totalmente opaca) a 0,0 (totalmente transparente).

Por defecto, el valor de esta propiedad es 1,0.

Esta función está disponible en las plataformas Linux embebido, macOS, Windows y X11 que admitan la extensión Composite.

Nota: En X11 es necesario que haya un gestor de composición en ejecución, y el átomo específico de X11 _NET_WM_WINDOW_OPACITY debe ser compatible con el gestor de ventanas que estés utilizando.

Advertencia: Cambiar esta propiedad de opaca a transparente puede generar un evento de pintura que debe procesarse antes de que la ventana se muestre correctamente. Esto afecta principalmente al uso de ` QScreen::grabWindow()`. Ten en cuenta también que las ventanas semitransparentes se actualizan y cambian de tamaño de forma significativamente más lenta que las ventanas opacas.

Funciones de acceso:

qreal windowOpacity() const
void setWindowOpacity(qreal level)

Véase también setMask().

windowTitle : QString

Esta propiedad contiene el título de la ventana (etiqueta)

Esta propiedad solo tiene sentido para los widgets de nivel superior, como ventanas y cuadros de diálogo. Si no se ha establecido ningún título, el título se basa en el windowFilePath. Si ninguno de estos está establecido, el título es una cadena vacía.

Si se utiliza el mecanismo « windowModified », el título de la ventana debe contener un marcador de posición «[*]», que indica dónde debe aparecer el «*». Normalmente, debería aparecer justo después del nombre del archivo (por ejemplo, «document1.txt[*] - Editor de texto»). Si la propiedad windowModified está establecida en « false » (valor por defecto), el marcador de posición simplemente se elimina.

En algunas plataformas de escritorio (incluidas Windows y Unix), el nombre de la aplicación (procedente de QGuiApplication::applicationDisplayName) se añade al final del título de la ventana, si está configurado. Esto lo realiza el complemento QPA, por lo que se muestra al usuario, pero no forma parte de la cadena windowTitle.

Funciones de acceso:

QString windowTitle() const
void setWindowTitle(const QString &)

Señal «Notifier»:

void windowTitleChanged(const QString &title)

Véase también windowIcon, windowModified y windowFilePath.

[read-only] x : int

Esta propiedad contiene la coordenada x del widget respecto a su elemento padre, incluyendo cualquier marco de ventana

Consulta la documentación sobre geometría de ventanas para obtener una visión general de las cuestiones relacionadas con la geometría de las ventanas.

Por defecto, esta propiedad tiene un valor de 0.

Funciones de acceso:

int x() const

Véase también frameGeometry, y y pos.

[read-only] y : int

Esta propiedad contiene la coordenada y del widget con respecto a su elemento padre, incluyendo cualquier marco de ventana

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los aspectos relacionados con la geometría de las ventanas.

Por defecto, esta propiedad tiene un valor de 0.

Funciones de acceso:

int y() const

Véase también frameGeometry, x y pos.

Documentación de las funciones de miembro

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

Crea un widget que es un elemento secundario de parent, con los indicadores del widget establecidos 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 secundaria dentro de parent. El nuevo widget se elimina cuando se elimina su parent.

El argumento de indicadores del widget, f, suele ser 0, pero se puede configurar para personalizar el marco de una ventana (es decir, parent debe ser nullptr). Para personalizar el marco, utiliza un valor compuesto por la operación OR bit a bit de cualquiera de los window flags.

Si añades un widget secundario a un widget que ya está visible, debes mostrar explícitamente el widget secundario para que sea visible.

Ten en cuenta que es posible que la versión de Qt para X11 no pueda ofrecer todas las combinaciones de indicadores de estilo en todos los sistemas. Esto se debe a que, en X11, Qt solo puede solicitar información al gestor de ventanas, y este puede anular la configuración de la aplicación. En Windows, Qt puede establecer los indicadores que desees.

Véase también windowFlags.

[virtual noexcept] QWidget::~QWidget()

Elimina el widget.

Primero se eliminan todos los elementos secundarios de este widget. La aplicación se cierra si este widget es el widget principal.

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

Este controlador de eventos se invoca con el objeto ` event ` proporcionado cada vez que se modifican las acciones del widget.

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

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

Devuelve la lista (que puede estar vacía) de las acciones de este widget.

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

void QWidget::activateWindow()

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

Una ventana activa es una ventana de nivel superior visible 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 quieres asegurarte de que la ventana también quede en primer plano, también debes llamar a ` raise()`. Ten en cuenta que la ventana debe estar visible; de lo contrario, `activateWindow()` no tendrá ningún efecto.

En Windows, si se llama a esta función cuando la aplicación no es la activa en ese momento, no la convertirá en la ventana activa. Cambia el color de la entrada de la barra de tareas para indicar que la ventana ha sufrido algún cambio. Esto se debe a que Microsoft no permite que una aplicación interrumpa lo que el usuario está haciendo en ese momento 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 « QAction». Sin embargo, pueden representarse gráficamente de muchas formas diferentes. El uso predeterminado de la lista « QAction » (tal y como la devuelve la función « actions()») es crear un «context QMenu ».

Un QWidget solo debe tener una instancia de cada acción, y añadir una acción que ya tenga no hará que esa misma acción aparezca dos veces en el widget.

La propiedad de action no se transfiere a este QWidget.

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

[since 6.3] QAction *QWidget::addAction(const QString &text)

[since 6.3] QAction *QWidget::addAction(const QIcon &icon, const QString &text)

[since 6.3] QAction *QWidget::addAction(const QString &text, const QKeySequence &shortcut)

[since 6.3] QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut)

Estas funciones de conveniencia crean una nueva acción con el texto « text », el icono « icon » y el atajo « shortcut », si los hay.

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

QWidget asume la propiedad del objeto devuelto QAction.

Estas funciones se introdujeron en Qt 6.3.

[since 6.3] template <typename... Args, typename = QWidget::compatible_action_slot_args<Args...>> QAction *QWidget::addAction(const QString &text, Args &&... args)

[since 6.3] template <typename... Args, typename = QWidget::compatible_action_slot_args<Args...>> QAction *QWidget::addAction(const QIcon &icon, const QString &text, Args &&... args)

[since 6.3] template <typename... Args, typename = QWidget::compatible_action_slot_args<Args...>> QAction *QWidget::addAction(const QString &text, const QKeySequence &shortcut, Args &&... args)

[since 6.3] template <typename... Args, typename = QWidget::compatible_action_slot_args<Args...>> QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut, Args &&... args)

Estas funciones de conveniencia crean una nueva acción con el texto « text », el icono « icon » y el atajo « shortcut », si los hay.

La señal « triggered()» de la acción se conecta como si se tratara de 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 Asume la propiedad del ` QAction` devuelto.

Estas funciones se introdujeron en Qt 6.3.

[since 6.3] QAction *QWidget::addAction(const QString &text, const QObject *receiver, const char *member, Qt::ConnectionType type = Qt::AutoConnection)

[since 6.3] QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QObject *receiver, const char *member, Qt::ConnectionType type = Qt::AutoConnection)

[since 6.3] QAction *QWidget::addAction(const QString &text, const QKeySequence &shortcut, const QObject *receiver, const char *member, Qt::ConnectionType type = Qt::AutoConnection)

[since 6.3] QAction *QWidget::addAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut, const QObject *receiver, const char *member, Qt::ConnectionType type = Qt::AutoConnection)

Esta función de conveniencia crea una nueva acción con el texto « text », el icono « icon » y el atajo « shortcut », si lo hay.

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

QWidget toma la propiedad del objeto QAction devuelto.

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 adapte a su contenido.

Esta función utiliza ` sizeHint()` si es válida, es decir, si la anchura y la altura de la sugerencia de tamaño son >= 0. De lo contrario, establece el tamaño en el rectángulo de los hijos que abarca todos los widgets hijos (la unión de todos los rectángulos de los widgets hijos).

En el caso de las ventanas, también se tiene en cuenta el tamaño de la pantalla. Si la función ` 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 del ancho y la altura de la pantalla.

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

QPalette::ColorRole QWidget::backgroundRole() const

Devuelve el papel de fondo del widget.

La función de fondo define el pincel del « palette » del widget que se utiliza para renderizar el fondo.

Si no se establece explícitamente ninguna función de fondo, el widget hereda la función de fondo de su widget padre.

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

QBackingStore *QWidget::backingStore() const

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

[virtual protected] void QWidget::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 a través del objeto ` event ` facilitado.

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 » y « QEvent::ReadOnlyChange ».

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

Devuelve el widget hijo visible situado 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 propio sistema de coordenadas del widget.

Esta es una función sobrecargada.

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

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

Esta es una función sobrecargada.

Esta función se introdujo en Qt 6.8.

void QWidget::clearFocus()

Retira el foco de entrada del teclado del widget.

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

Este widget debe habilitar la configuración de foco para obtener el foco de entrada del teclado; es decir, debe llamar a setFocusPolicy().

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

void QWidget::clearMask()

Elimina cualquier máscara establecida mediante la función ` setMask()`.

Véase también setMask().

[slot] bool QWidget::close()

Cierra este widget. Devuelve « true » si el widget se ha cerrado; en caso contrario, devuelve « false ».

En primer lugar, envía al widget un QCloseEvent. El widget recibe un hidden si accepts el evento de cierre. Si ignores el evento, no ocurre nada. La implementación predeterminada de QWidget::closeEvent() acepta el evento de cierre.

Si el widget tiene el indicador « Qt::WA_DeleteOnClose », también se elimina. Se envía un evento de cierre al widget independientemente de si este está visible o no.

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

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

Este controlador de eventos se invoca con el objeto ` event ` especificado cuando Qt recibe una solicitud de cierre de ventana para un widget de nivel superior procedente del sistema de ventanas.

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

Las aplicaciones con ventana principal suelen utilizar reimplementaciones de esta función para comprobar si se ha guardado el trabajo del usuario y solicitar 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 del contenido del widget.

Véanse también « setContentsMargins()» y « contentsRect()».

QRect QWidget::contentsRect() const

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

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos del menú contextual del widget.

El controlador se invoca cuando el contextMenuPolicy del widget es Qt::DefaultContextMenu.

La implementación por defecto ignora el evento de contexto. Consulta la documentación de ` QContextMenuEvent ` para obtener 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 se ignoran en Qt 5. Utiliza QWindow::fromWinId() para crear un objeto QWindow que envuelva una ventana externa y pásalo 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 integrar ` window ` en una aplicación basada en ` QWidget`.

El contenedor de la ventana se crea como elemento secundario de parent y con los indicadores de ventana flags.

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

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

El contenedor de ventanas se adjunta como una ventana hija nativa a la ventana de nivel superior de la que es hija. Cuando un contenedor de ventanas se utiliza como hijo de una QAbstractScrollArea o una QMdiArea, creará una native window para cada widget de su cadena de padres, a fin de permitir un 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 realizarse antes de mostrar el contenedor de ventanas. Las aplicaciones con muchas ventanas hijas nativas pueden sufrir problemas de rendimiento.

El contenedor de ventanas presenta una serie de limitaciones conocidas:

  • Orden de apilamiento: la ventana incrustada se apilará en la parte superior de la jerarquía de widgets como un cuadro opaco. El orden de apilamiento de varias instancias superpuestas del contenedor de ventanas no está definido.
  • Integración de renderizado: el contenedor de ventanas no es compatible con QGraphicsProxyWidget, QWidget::render() ni funcionalidades similares.
  • Gestión del foco: es posible configurar la instancia del contenedor de ventana con cualquier política de foco, y esta delegará el foco a la ventana mediante una llamada a ` QWindow::requestActivate()`. Sin embargo, el retorno a la cadena de foco normal desde la instancia ` QWindow ` dependerá de la propia implementación de la instancia ` QWindow `. Además, el hecho de que ` QWindow::requestActivate()` conceda realmente el foco a la ventana depende de la plataforma.

    Si se incrusta una ventana basada en Qt Quick, Qt se asegurará automáticamente de que al pulsar la tecla Tab se realice la transición de entrada y salida de la ventana QML incrustada, lo que permite que el foco se desplace al siguiente o al anterior objeto con foco en la cadena de contenedores de la ventana.

  • El uso de muchas instancias de contenedores de ventanas en una aplicación basada en ` QWidget` puede afectar considerablemente al rendimiento general de la aplicación.

Nota: Si ` window ` pertenece a un widget (es decir, si se ha recibido ` window ` al llamar a ` windowHandle()`), no se creará ningún contenedor. En su lugar, esta función devolverá el propio widget, tras haber sido reasignado a ` parent`. Dado que no se creará ningún contenedor, se ignorará ` flags `. En otras palabras, si window pertenece a un widget, considera simplemente reasignar ese widget a parent en lugar de utilizar esta función.

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

Esta señal se emite cuando el 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 del menú contextual que recibe el widget. Normalmente, esta posición se expresa en coordenadas del widget. La excepción a esta regla son QAbstractScrollArea y sus subclases, que asignan el evento del menú contextual a las coordenadas de 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. Elimina la ventana del widget si destroyWindow es verdadero.

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

Esta función suele llamarse desde el destructor de ` QWidget `.

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

Este controlador de eventos se activa cuando se está realizando un arrastre y el ratón entra en este widget. El evento se pasa a través del parámetro ` event `.

Si se ignora el evento, el widget no recibirá ningún objeto ` drag move events`.

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

Véase también « QDrag » y « QDragEnterEvent ».

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

Este controlador de eventos se activa cuando se está realizando un arrastre y el ratón sale de este widget. El evento se pasa a través del parámetro ` event `.

Consulta la documentación sobre arrastrar y soltar para obtener una descripción general de cómo implementar la función de arrastrar y soltar en tu aplicación.

Consulte también QDrag y QDragLeaveEvent.

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

Este controlador de eventos se activa si se está realizando un arrastre y cuando se da cualquiera de las siguientes condiciones: el cursor entra en este widget, el cursor se desplaza dentro de este widget o se pulsa una tecla modificadora en el teclado mientras este widget tiene el foco. El evento se pasa a través del parámetro ` event `.

Consulta la documentación sobre arrastrar y soltar para obtener una descripción general de cómo implementar la función de arrastrar y soltar en tu aplicación.

Véanse también QDrag y QDragMoveEvent.

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

Este controlador de eventos se activa cuando se suelta el elemento arrastrado sobre este widget. El evento se pasa a través del parámetro ` event `.

Consulta la documentación sobre arrastrar y soltar para obtener una descripción general de cómo implementar la función de arrastrar y soltar en tu aplicación.

Consulte 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 widget padre nativo.

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

Nota: Se recomienda no almacenar este valor, ya que es probable que cambie en tiempo de ejecución.

Véase también nativeParentWidget().

void QWidget::ensurePolished() const

Garantiza que el widget y sus elementos secundarios hayan sido optimizados mediante QStyle (es decir, que tengan una fuente y una paleta adecuadas).

QWidget Llama a esta función una vez que se ha construido por completo, 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, podría ser necesario el tamaño de fuente correcto en la reimplementación de ` sizeHint()` del widget. Ten en cuenta que esta función se llama desde la implementación predeterminada de ` sizeHint()`.

El «pulido» resulta útil para la inicialización final que debe realizarse después de que se hayan llamado todos los constructores (tanto de las clases base como de las subclases).

Si necesitas modificar alguna configuración durante el «polishing» de un widget, reimplementa event() y gestiona el tipo de evento QEvent::Polish.

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

Véase también event().

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de entrada al widget, que se pasan a través del parámetro « event ».

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

Véase también ` leaveEvent()`, ` mouseMoveEvent()` y ` event()`.

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

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

Este es el controlador de eventos principal; gestiona el evento event. Puedes reimplementar esta función en una subclase, pero te recomendamos utilizar en su lugar uno de los controladores de eventos especializados.

Los eventos de pulsación y liberación de teclas se tratan de forma diferente al resto de eventos. La función `event()` comprueba si se han pulsado las teclas Tab y Shift+Tab e intenta desplazar el foco adecuadamente. Si no hay ningún widget al que desplazar el foco (o si la tecla pulsada no es Tab ni Shift+Tab), `event()` llama a ` keyPressEvent()`.

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

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

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 el identificador/mánejador de ventana id.

El tipo de identificador de ventana depende del sistema de ventanas subyacente; consulta qwindowdefs.h para ver la definición concreta. Si no existe ningún widget con este identificador, se devuelve nullptr.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de foco del teclado (foco recibido) para el widget. El evento se pasa a través del parámetro ` event `.

Normalmente, un widget debe definir setFocusPolicy() con un valor 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 en el caso de 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 asignar el foco del teclado, según corresponda a Tab, y devuelve true si encuentra un nuevo widget, o false si no lo encuentra.

Véase también focusPreviousChild().

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

Busca un nuevo widget al que asignar el foco del teclado, según corresponda para las teclas Tab y Mayús+Tab, y devuelve « true » si encuentra un nuevo widget, o «false» si no lo encuentra.

Si ` next ` es `true`, esta función busca hacia adelante; si ` next ` es `false`, busca hacia atrás.

En ocasiones, es posible que desees reimplementar esta función. Por ejemplo, un navegador web podría reimplementarla para desplazar su «enlace activo actual» hacia adelante o hacia atrás, y llamar a `focusNextPrevChild()` 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 así el control del recorrido del foco para todos los widgets hijos.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de foco del teclado (pérdida de foco) para el widget. Los eventos se pasan a través del parámetro ` event `.

Normalmente, un widget debe definir ` setFocusPolicy()` con un valor 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 en el caso de 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 asignar el foco del teclado, según corresponda a Shift+Tab, y devuelve true si encuentra un nuevo widget, o false si no lo encuentra.

Véase también focusNextChild().

QWidget *QWidget::focusProxy() const

Devuelve el proxy de foco o, en caso de que no haya ninguno, ` nullptr `.

Véase también setFocusProxy().

QWidget *QWidget::focusWidget() const

Devuelve el último elemento secundario de este widget sobre el que se haya llamado a ` setFocus `. En el caso de los widgets de nivel superior, se trata del widget que obtendrá el foco en caso de que se active esta ventana

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

QFontInfo QWidget::fontInfo() const

Devuelve la información sobre la fuente actual del widget. Equivalente 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. Equivalente a QFontMetrics(widget->font()).

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

QPalette::ColorRole QWidget::foregroundRole() const

Devuelve el papel de primer plano.

El rol de primer plano define el color de la paleta de colores del widget ( palette ) que se utiliza para dibujar el primer plano.

Si no se ha establecido explícitamente ningún 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)))

Representa el widget en un mapa de píxeles limitado por el valor dado en ` rectangle`. Si el widget tiene elementos secundarios, estos también se dibujan en las posiciones correspondientes.

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

Nota: Esta función se puede invocar a través del sistema de metaobjetos y desde QML. Véase Q_INVOKABLE.

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

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

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

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

void QWidget::grabKeyboard()

Captura la entrada del teclado.

Este widget recibe todos los eventos de teclado hasta que se llama a ` releaseKeyboard()`; los demás widgets no reciben ningún evento de teclado. Los eventos del ratón no se ven afectados. Utiliza ` grabMouse()` si quieres capturar esos eventos.

El widget de foco no se ve afectado, salvo que no recibe ningún evento de teclado. La función ` setFocus()` desplaza el foco como de costumbre, pero el nuevo widget de foco solo recibe eventos de teclado una vez que se ha llamado a ` releaseKeyboard()`.

Si otro widget está capturando la entrada del teclado en ese momento, primero se libera la captura de ese widget.

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

void QWidget::grabMouse()

Captura la entrada del ratón.

Este widget recibe todos los eventos del ratón hasta que se llama a releaseMouse(); los demás widgets no reciben ningún evento del ratón. Los eventos del teclado no se ven afectados. Utiliza grabKeyboard() si quieres capturar esos eventos.

Advertencia: Los errores en las aplicaciones que capturan el ratón suelen bloquear el terminal con mucha frecuencia. Utiliza esta función con extrema precaución y considera la posibilidad de usar la opción de línea de comandos ` -nograb ` mientras depuras.

Rara vez es necesario capturar el ratón cuando se utiliza Qt, ya que Qt lo captura y lo libera de forma adecuada. En concreto, Qt captura el ratón cuando se pulsa un botón del ratón y lo mantiene hasta que se suelta el último botón.

Nota: Solo los widgets visibles pueden capturar la entrada del ratón. Si isVisible() devuelve « false » para un widget, dicho widget no puede llamar a grabMouse().

Nota: En Windows, `grabMouse()` solo funciona cuando el ratón se encuentra dentro de una ventana propiedad del proceso. En macOS, `grabMouse()` solo funciona cuando el ratón se encuentra dentro del marco de ese widget.

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

void QWidget::grabMouse(const QCursor &cursor)

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

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

Advertencia: Capturar el ratón podría bloquear el terminal.

Nota: Consulta la nota en QWidget::grabMouse().

Esta función sobrecarga QWidget::grabMouse().

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

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

Añade un atajo al sistema de atajos de Qt que espera la secuencia « key » especificada en el « context » indicado. Si el « context » es « Qt::ApplicationShortcut », el atajo se aplica a toda la aplicación. De lo contrario, es local para este widget (« Qt::WidgetShortcut ») o para la propia ventana (« Qt::WindowShortcut »).

Si varios widgets han capturado la misma secuencia « key », 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 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() y setShortcutEnabled().

QGraphicsEffect *QWidget::graphicsEffect() const

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

Si el widget no tiene ningún efecto gráfico, se devuelve ` nullptr `.

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

QGraphicsProxyWidget *QWidget::graphicsProxyWidget() const

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

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

[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 predeterminada devuelve la altura preferida del diseño. Si no hay ningún diseño, la implementación predeterminada devuelve -1, lo que indica que la altura preferida no depende del ancho.

[slot] void QWidget::hide()

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

Nota: Si estás trabajando con ` QDialog ` o sus subclases y llamas a la función ` show()` después de esta función, el cuadro de diálogo se mostrará en su posición original.

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

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de ocultación de widgets. El evento se pasa a través del parámetro « event ».

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

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

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

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

Inicializa el lápiz ( painter ), el fondo y la fuente para que coincidan con los del widget indicado. Esta función se invoca automáticamente cuando se abre el «painter» en un « QWidget ».

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de composición del método de entrada. Este controlador se activa cuando cambia el estado del método de entrada.

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

La implementación predeterminada llama a `event->ignore()`, lo que rechaza el evento del método de entrada. Consulte la documentación de ` QInputMethodEvent ` para obtener más detalles.

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

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

Este método solo es relevante para los widgets de entrada. El método de entrada lo utiliza para consultar un conjunto de propiedades del widget con el fin de poder admitir operaciones complejas del método de entrada, como el soporte para el texto circundante y las 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 al final si before es nullptr o si before no es una acción válida para este widget.

Un « QWidget » solo debe contener una instancia 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 al final si « before » es « nullptr » o si « 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 ` child` indicado, y ambos widgets se encuentran dentro de la misma ventana; en caso contrario, devuelve ` false`.

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

Devuelve ` true ` si este widget se activara en caso de que ` ancestor ` estuviera activado; en caso contrario, devuelve ` false`.

Esto ocurre si ni el propio widget ni ninguno de sus padres hasta ancestor (excluido este último) han sido desactivados explícitamente.

isEnabledTo(0) devuelve «false» si este widget o cualquiera de sus antepasados se ha desactivado explícitamente.

El término «antepasado» se refiere aquí a 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 solo se hará visible cuando se llame a show() sobre él. No se mostrará automáticamente cuando se muestre el elemento padre.

Para comprobar la visibilidad, utiliza en su lugar !isVisible() (fíjate en el signo de exclamación).

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

Los widgets están ocultos si:

  • se crearon como ventanas independientes,
  • se crearon como hijos de widgets visibles,
  • hidese ha llamado a () o a setVisible(false).

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

Devuelve ` true ` si este widget pasara a ser visible en caso de que se mostrara ` ancestor `; en caso contrario, devuelve ` false`.

El caso «true» se da si ni el propio widget ni ningún elemento padre hasta ancestor (excluido este último) se han ocultado explícitamente.

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 se movieran dichas ventanas.

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, visualmente, no es hijo de ningún otro widget y que suele tener un marco y un « window title ».

Una ventana puede tener un parent widget. En ese caso, se agrupará con su padre y se eliminará cuando se elimine este, se minimizará cuando se minimice este, etc. Si el gestor de ventanas lo admite, también compartirá una entrada en la barra de tareas con su padre.

QDialog Los widgets « QMainWindow » son, por defecto, ventanas, incluso si se especifica un widget padre en el constructor. Este comportamiento viene determinado por el indicador « Qt::Window ».

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de pulsación de teclas del widget.

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

Si reimplementas este controlador, es muy importante que llames a la implementación de la clase base si no vas a realizar ninguna acción con respecto a 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). De lo contrario, el evento se ignora, de modo que el padre del widget pueda interpretarlo.

Ten en cuenta que « QKeyEvent » comienza con `isAccepted()` == `true`, por lo que no es necesario llamar a ` QKeyEvent::accept()`; simplemente no llames a la implementación de la clase base si actúas sobre la tecla.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de liberación de teclas del widget.

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

Si reimplementas este controlador, es muy importante que llames a la implementación de la clase base si no vas a realizar ninguna acción con respecto a la tecla.

La implementación predeterminada ignora el evento, de modo que el padre del widget pueda interpretarlo.

Ten en cuenta que ` QKeyEvent ` comienza con `isAccepted()` == `true`, por lo que no es necesario llamar a ` QKeyEvent::accept()`; simplemente no llames a la implementación de la clase base si realizas alguna acción con respecto a la tecla.

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

[static] QWidget *QWidget::keyboardGrabber()

Devuelve el widget que actualmente tiene el control de la entrada del teclado.

Si ningún widget de esta aplicación está capturando actualmente la entrada del teclado, se devuelve ` nullptr `.

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

QLayout *QWidget::layout() const

Devuelve el gestor de diseño instalado en este widget, o bien « nullptr » si no hay ningún gestor de diseño instalado.

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

Véase también setLayout(), sizePolicy() y Gestión de diseños.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de salida del widget, que se pasan a través del parámetro « event ».

Se envía un evento de salida al widget cuando el cursor del ratón sale de él.

Véase también enterEvent(), mouseMoveEvent() y event().

[slot] void QWidget::lower()

Coloca el widget en la parte inferior de la pila del widget padre.

Tras esta llamada, el widget quedará visualmente detrás (y, por lo tanto, oculto por) cualquier widget hermano que se superponga.

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

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

Transforma las coordenadas del widget pos del 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 realiza la llamada.

Esta función se introdujo en Qt 6.0.

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

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

Esta es una función sobrecargada.

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

Convierte las coordenadas globales de la pantalla pos en 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

Esta es una función sobrecargada.

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

Convierte las coordenadas del widget padre pos en coordenadas del widget.

Equivale a ` 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

Esta es una función sobrecargada.

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

Convierte las coordenadas del widget pos al sistema de coordenadas de parent. El parent no debe ser nullptr y debe ser un padre del widget que realiza la llamada.

Esta función se introdujo en Qt 6.0.

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

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

Esta es una función sobrecargada.

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

Convierte las coordenadas del widget pos en coordenadas globales de la pantalla. Por ejemplo, mapToGlobal(QPointF(0,0)) devolvería las coordenadas globales del píxel superior izquierdo del widget.

Esta función se introdujo en Qt 6.0.

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

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

Esta es una función sobrecargada.

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

Convierte la coordenada del widget pos en una coordenada del widget padre.

Equivale a mapToGlobal() si el widget no tiene ningún padre.

Esta función se introdujo en Qt 6.0.

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

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

Esta es una función sobrecargada.

QRegion QWidget::mask() const

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

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

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

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

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

m es la métrica que se desea obtener.

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de doble clic del ratón para el widget.

La implementación predeterminada llama a mousePressEvent().

Nota: El widget también recibirá eventos de pulsación y liberación del ratón, además del evento de doble clic. Y si otro widget que se superpone a este desaparece en respuesta a eventos de pulsación o liberación, entonces este widget solo recibirá el evento de doble clic. Corresponde al desarrollador asegurarse de que la aplicación interprete estos eventos correctamente.

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

[static] QWidget *QWidget::mouseGrabber()

Devuelve el widget que tiene actualmente el control del ratón.

Si ningún widget de esta aplicación está capturando la entrada del ratón en ese momento, se devuelve ` nullptr `.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse 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 solo 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. En el caso de los eventos de pulsación y liberación, la posición suele ser la misma que la del último evento de movimiento del ratón, pero puede variar si la mano del usuario tiembla. Se trata de una característica del sistema de ventanas subyacente, no de Qt.

Si deseas mostrar una información sobre herramientas inmediatamente, mientras el ratón se está moviendo (por ejemplo, para obtener las coordenadas del ratón con QMouseEvent::position() y mostrarlas como información sobre herramientas), primero debes habilitar el seguimiento del ratón tal y como se ha descrito anteriormente. A continuación, para garantizar que la información sobre herramientas se actualice de inmediato, debes llamar a ` QToolTip::showText()` en lugar de ` setToolTip()` en tu implementación de `mouseMoveEvent()`.

Véase también setMouseTracking(), mousePressEvent(), mouseReleaseEvent(), mouseDoubleClickEvent(), event(), QMouseEvent y el ejemplo «Scribble».

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

Este controlador de eventos, para el evento ` event`, puede reimplementarse en una subclase para recibir eventos de pulsación del ratón para el widget.

Si se crean nuevos widgets en la función `mousePressEvent()`, es posible que el evento ` mouseReleaseEvent()` no termine donde se espera, dependiendo del sistema de ventanas subyacente (o del gestor de ventanas X11), la ubicación de los widgets y quizá otros factores.

La implementación predeterminada cierra los widgets emergentes cuando se hace clic fuera de la ventana. Para otros tipos de widgets, no realiza ninguna acción.

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

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

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de suelta del ratón para el widget.

Véase también mousePressEvent(), mouseDoubleClickEvent(), mouseMoveEvent(), event(), QMouseEvent y el ejemplo «Scribble».

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

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

Nota: Funciónde asignación para la propiedad pos.

Se trata de una función sobrecargada.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de desplazamiento del widget que se pasan a través del parámetro event. Cuando el widget recibe este evento, ya se encuentra en la nueva posición.

Se puede acceder a la posición anterior a través de ` QMoveEvent::oldPos()`.

Véase también ` resizeEvent()`, ` event()`, ` move()` y ` QMoveEvent`.

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

Este controlador de eventos especial se puede reimplementar en una subclase para recibir eventos nativos de la plataforma identificados por eventType, que se pasan en el parámetro message.

En tu reimplementación de esta función, si deseas impedir que Qt gestione el evento, devuelve true y establece result. El parámetro result solo tiene sentido en Windows. Si devuelves false, este evento nativo se devuelve a Qt, que lo convierte en un evento de Qt y lo envía al widget.

Nota: Los eventos solo se envían a este controlador de eventos si el widget tiene un identificador de ventana nativo.

Nota: Esta función sustituye a las funciones de filtro de eventos x11Event(), winEvent() y macEvent() de Qt 4.

PlataformaIdentificador del tipo de eventoTipo de mensajeTipo de resultado
Windows«windows_generic_MSG»MSG *LRESULT
macOS«NSEvent»NSEvent *
XCB«xcb_generic_event_t»xcb_generic_event_t *

Véase también QAbstractNativeEventFilter.

QWidget *QWidget::nativeParentWidget() const

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

Véase también effectiveWinId().

QWidget *QWidget::nextInFocusChain() const

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

Véase también previousInFocusChain().

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

Establece los indicadores de ventana del widget en « flags », sin notificárselo al sistema de ventanas.

Advertencia: No llames a esta función a menos que sepas realmente lo que estás haciendo.

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

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

Reimplementa: ` QPaintDevice::paintEngine()` const.

Devuelve el motor de pintura del widget.

Ten en cuenta que el usuario no debe llamar a esta función de forma explícita, ya que está pensada únicamente para su reimplementación. Qt llama a esta función internamente, y es posible que la implementación por defecto no siempre devuelva un puntero válido.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de pintura pasados a través de ` event`.

Un evento de pintura es una solicitud para volver a dibujar todo o parte de un widget. Puede producirse por una de las siguientes razones:

  • repaintse ha invocado `()` o ` update()`,
  • el widget estaba oculto y ahora se ha vuelto a mostrar, o
  • por muchas otras razones.

Muchos widgets pueden simplemente volver a dibujar toda su superficie cuando se les solicita, pero algunos widgets lentos necesitan optimizar el proceso dibujando solo la región solicitada: ` QPaintEvent::region()`. Esta optimización de velocidad no cambia el resultado, ya que el dibujo se recorta a esa región durante el procesamiento del evento. ` QListView ` y ` QTableView ` lo hacen, por ejemplo.

Qt también intenta acelerar el pintado fusionando varios eventos de pintado en uno solo. Cuando se llama varias veces a update() o el sistema de ventanas envía varios eventos de pintado, Qt fusiona estos eventos en uno solo con una región más amplia (véase QRegion::united()). La función repaint() no permite esta optimización, por lo que recomendamos utilizar update() siempre que sea posible.

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

El fondo se puede configurar mediante setBackgroundRole() y setPalette().

Desde Qt 4.0, ` QWidget ` aplica automáticamente el doble búfer a su dibujo, por lo que no es necesario escribir código de doble búfer en `paintEvent()` para evitar el parpadeo.

Nota: Por lo general , se debe evitar llamar a update() o repaint() dentro de paintEvent(). Por ejemplo, llamar a update() o repaint() sobre elementos hijos dentro de paintEvent() da lugar a un comportamiento indefinido; el elemento hijo puede recibir o no un evento de pintura.

Advertencia: Si utilizas un motor de pintura personalizado sin el «backingstore» de Qt, debes establecer ` Qt::WA_PaintOnScreen `. De lo contrario, nunca se llamará a ` QWidget::paintEngine()`; en su lugar, se utilizará el «backingstore».

Véase también event(), repaint(), update(), QPainter, QPixmap, QPaintEvent y Analog Clock.

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 `InFocusChain` devuelve el widget anterior en la cadena de enfoque de este widget.

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

[slot] void QWidget::raise()

Coloca este widget en la parte superior de la pila del widget padre.

Tras esta llamada, el widget aparecerá visualmente por delante de cualquier widget hermano que se superponga.

Nota: Al utilizar ` activateWindow()`, puedes llamar a esta función para asegurarte de que la ventana quede en la parte superior de la pila.

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

void QWidget::releaseKeyboard()

Libera el control del teclado.

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

void QWidget::releaseMouse()

Suelta el botón del ratón.

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

void QWidget::releaseShortcut(int id)

Elimina el atajo con el « id » indicado del sistema de atajos de Qt. El widget dejará de recibir eventos « QEvent::Shortcut » correspondientes a la secuencia de teclas del atajo (a menos que tenga otros atajos con la misma secuencia de teclas).

Advertencia: Normalmente nodebería ser necesario utilizar esta función, ya que el sistema de atajos de Qt elimina los atajos automáticamente cuando se destruye su widget padre. Es recomendable utilizar QAction o QShortcut para gestionar los atajos, ya que son más fáciles de usar que esta función de bajo nivel. Tenga en cuenta también que se trata de una operación costosa.

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))

Representa el ` sourceRegion ` de este widget en el ` target ` utilizando ` renderFlags ` para determinar cómo realizar la representación. La representació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úrate de llamar a QPainter::end() para el pintor activo del dispositivo target (si lo hay) antes de realizar el renderizado. Por ejemplo:

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

Nota: Para obtener el contenido de un ` QOpenGLWidget`, utiliza en su lugar ` QOpenGLWidget::grabFramebuffer()`.

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

Representa el widget en el método QPainter::device() de painter.

Las transformaciones y la configuración aplicadas al painter se utilizarán al renderizar.

Nota: El painter debe estar activo. En macOS, el widget se representará en un QPixmap y, a continuación, se dibujará mediante el painter.

Esta es una función sobrecargada.

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

[slot] void QWidget::repaint()

Vuelve a dibujar el widget directamente llamando a ` paintEvent()` de forma inmediata, a menos que las actualizaciones estén desactivadas o el widget esté oculto.

Recomendamos utilizar repaint() únicamente si se necesita un redibujado inmediato, por ejemplo, durante una animación. En la mayoría de los casos, es preferible utilizar update(), ya que permite a Qt optimizar la velocidad y minimizar el parpadeo.

Advertencia: Si llamas a repaint() en una función que a su vez pueda ser llamada desde paintEvent(), podrías provocar una recursión infinita. La función update() nunca provoca recursión.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// 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(); });
Para ver más ejemplos y enfoques, consulta «Conexión a slots sobrecargados».

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

void QWidget::repaint(const QRect &rect)

Esta versión vuelve a dibujar un rectángulo rect dentro del widget.

Se trata de una función sobrecargada.

void QWidget::repaint(const QRegion &rgn)

Esta versión vuelve a dibujar una región rgn dentro del widget.

Se trata de una función sobrecargada.

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

Esta versión vuelve a dibujar 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.

Se trata de una función sobrecargada.

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

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

Nota: Funciónde asignación para la propiedad size.

Se trata de una función sobrecargada.

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

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de redimensionamiento del widget, que se pasan a través del parámetro « event ». Cuando se llama a «resizeEvent()», el widget ya tiene su nueva geometría. Se puede acceder al tamaño anterior mediante « QResizeEvent::oldSize()».

El widget se borrará y recibirá un evento de pintura inmediatamente después de procesar el evento de cambio de tamaño. No es necesario (ni se debe) realizar ningún dibujo dentro de este controlador.

Véase también moveEvent(), event(), resize(), QResizeEvent, paintEvent() y el ejemplo «Scribble».

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 si la operación se realiza correctamente; en caso contrario, devuelve false.

Si la geometría restaurada queda fuera de la pantalla, se modificará para que quede dentro de la geometría disponible en pantalla.

Para restaurar la geometría guardada mediante QSettings, puedes utilizar un código como este:

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

Consulta la documentación sobre geometría de ventanas para obtener una visión general de los problemas de geometría relacionados con las ventanas.

Utiliza ` QMainWindow::restoreState()` para restaurar la geometría y el estado de las barras de herramientas y los widgets acoplados.

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

QByteArray QWidget::saveGeometry() const

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

Para guardar la geometría al cerrar la ventana, 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 sobre geometría de ventanas para obtener una visión general de los problemas de geometría relacionados con las ventanas.

Utilice ` QMainWindow::saveState()` para guardar la geometría y el estado de las barras de herramientas y los widgets acoplados.

Véanse 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, incluidos sus elementos hijos, dx píxeles hacia la derecha y dy hacia abajo. Tanto dx como dy pueden ser valores negativos.

Tras el desplazamiento, los widgets recibirán eventos de dibujo para las áreas que deban redibujarse. En el caso de los widgets que Qt reconoce como opacos, esto afecta únicamente a las partes recién expuestas. Por ejemplo, si un widget opaco se desplaza 8 píxeles hacia la izquierda, solo será necesario actualizar una franja de 8 píxeles de ancho en el borde derecho.

Dado que los widgets propagan el contenido de sus padres de forma predeterminada, es necesario establecer la propiedad ` autoFillBackground ` o utilizar ` setAttribute()` para establecer el atributo ` Qt::WA_OpaquePaintEvent `, a fin de que un widget sea opaco.

En el caso de los widgets que utilizan la propagación de contenidos, un desplazamiento provocará la 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 solo desplaza el elemento « r » y no mueve los elementos secundarios del widget.

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

Esta es una función sobrecargada.

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 la función de fondo del widget como « role ».

La función de fondo define el pincel de la propiedad « palette » del widget que se utiliza para renderizar el fondo.

Si « role » es « QPalette::NoRole », el widget hereda la función de fondo de su padre.

Ten en cuenta que los estilos pueden elegir libremente cualquier color de la paleta. Puedes modificar la paleta o establecer una hoja de estilos si no consigues el resultado deseado con setBackgroundRole().

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

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

Esto se corresponde con setBaseSize(QSize(basew, baseh)). Establece el tamaño base del widget con un ancho de basew y una altura de baseh.

Nota: Funciónsetter para la propiedad baseSize.

Esta es una función sobrecargada.

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 con los siguientes tamaños: left, top, right y bottom. El sistema de diseño utiliza estos márgenes, y las subclases pueden utilizarlos para especificar el área en la que se va a dibujar (por ejemplo, excluyendo el marco).

Al modificar los márgenes se activará un evento « 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 con los tamaños determinados por margins. Los márgenes son utilizados por el sistema de maquetación y pueden ser empleados por las subclases para especificar el área en la que se debe dibujar (por ejemplo, excluyendo el marco).

Al modificar los márgenes se activará un ` resizeEvent()`.

Esta es una función sobrecargada.

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

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

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

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

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

void QWidget::setFixedHeight(int h)

Establece tanto la altura mínima como la máxima del widget en h sin modificar los anchos. Se proporciona para mayor comodidad.

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

void QWidget::setFixedSize(const QSize &s)

Establece tanto el tamaño mínimo como el máximo del widget en s, lo que impide que aumente o disminuya de tamaño en ningún momento.

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

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

Como alternativa, si deseas que el widget tenga un tamaño fijo en función de su contenido, puedes llamar a ` QLayout::setSizeConstraint` (QLayout::SetFixedSize);

Véase también maximumSize y minimumSize.

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

Establece el ancho del widget en ` w ` y la altura en ` h`.

Esta es una función sobrecargada.

void QWidget::setFixedWidth(int w)

Establece tanto el ancho mínimo como el máximo del widget en w sin modificar las alturas. Se proporciona para mayor comodidad.

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

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

Otorga el foco de entrada del 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 utiliza para explicar qué ha provocado que el widget obtenga el foco. Si la ventana no está activa, el widget recibirá el foco cuando la ventana pase a estar activa.

En primer lugar, se envía un evento de cambio de foco inminente al widget de foco (si lo hay) para indicarle que está a punto de perder el foco. A continuación, se cambia el foco: se envía un evento «focus out» al elemento que tenía el foco anteriormente y un evento «focus in» al nuevo elemento para indicarle que acaba de recibir el foco. (No ocurre nada si los widgets de «focus in» y «focus out» son el mismo).

Nota: En plataformas integradas, setFocus() no provocará que el método de entrada abra un panel de entrada. Si deseas que esto ocurra, debes enviar tú mismo un evento « QEvent::RequestSoftwareInputPanel » al widget.

setFocus() otorga el foco a un widget independientemente de su política de foco, pero no libera el control del teclado (véase grabKeyboard()).

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

Advertencia: Si llamas a setFocus() en una función que a su vez pueda ser llamada desde focusOutEvent() o focusInEvent(), podrías provocar una recursión infinita.

Véase también hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(), setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(), grabMouse(), «Foco del teclado en widgets» y QEvent::RequestSoftwareInputPanel.

[slot] void QWidget::setFocus()

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

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

// 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(); });
Para ver más ejemplos y métodos, consulta «Conexión a ranuras sobrecargadas».

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 ningún proxy de foco.

Algunos widgets pueden «tener el foco», pero crean un widget secundario, como QLineEdit, para gestionar realmente el foco. En este caso, el widget puede establecer el campo de edición de línea como su proxy de foco.

setFocusProxy() establece el widget que realmente recibirá el foco cuando «este widget» lo obtenga. Si hay un proxy de foco, setFocus() y hasFocus() actúan sobre el proxy de foco. Si «este widget» es el widget de foco, entonces setFocusProxy() desplaza el foco al nuevo proxy de foco.

Véase también focusProxy().

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

Establece el papel de primer plano del widget en « role ».

El rol de primer plano define el color de la « 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.

Ten en cuenta que los estilos pueden elegir libremente cualquier color de la paleta. Puedes modificar la paleta o definir una hoja de estilos si no consigues el resultado deseado con setForegroundRole().

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

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

Esto se corresponde con setGeometry(QRect(x, y, w, h)).

Nota: Funciónsetter para la propiedad geometry.

Se trata de una función sobrecargada.

Véase también geometry().

void QWidget::setGraphicsEffect(QGraphicsEffect *effect)

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

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

Si effect es el efecto instalado en otro widget, setGraphicsEffect() eliminará el efecto de ese widget y lo instalará en este widget.

QWidget Asume la propiedad de effect.

Nota: Esta función aplicará el efecto a sí misma y a todos sus elementos hijos.

Nota: Los efectosgráficos no son compatibles con los widgets basados en OpenGL, como QGLWidget, QOpenGLWidget y QQuickWidget.

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 de este widget como « layout ».

Si ya hay un gestor de diseño instalado en este widget, QWidget no te permitirá instalar otro. Primero debes eliminar 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 otro widget, setLayout() cambiará la relación de parentesco del 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 diseño.

El QWidget asumirá la propiedad de layout.

Véase también ` layout()` y «Gestión de diseños».

void QWidget::setMask(const QBitmap &bitmap)

Hace que solo sean visibles los píxeles del widget para los que « bitmap » tenga un bit 1 correspondiente. Si la región incluye píxeles fuera del « rect()» del widget, los controles del sistema de ventanas de esa zona pueden ser visibles o no, dependiendo de la plataforma.

Ten en cuenta que este efecto puede resultar lento si la región es especialmente compleja.

El siguiente código muestra cómo se puede utilizar una imagen con 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 que muestra este código se enmascara utilizando la imagen que contiene, lo que da la impresión de que se está dibujando una imagen de forma irregular directamente sobre la pantalla.

Los widgets enmascarados reciben eventos del ratón únicamente en sus partes visibles.

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

void QWidget::setMask(const QRegion &region)

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

Dado que QRegion permite crear regiones de complejidad arbitraria, las máscaras de los widgets pueden diseñarse para adaptarse a ventanas con las formas más inusuales, e incluso permiten que los widgets se muestren con huecos. Ten en cuenta que este efecto puede ralentizar el sistema si la región es especialmente compleja.

Las máscaras de widget se utilizan para indicar al sistema de ventanas que la aplicación no desea eventos del ratón en las áreas situadas fuera de la máscara. En la mayoría de los sistemas, también dan lugar a un recorte visual aproximado. Para obtener bordes de ventana suaves, utiliza en su lugar un fondo translúcido y un dibujo con suavizado, tal y como se muestra en el ejemplo «Fondo translúcido ».

Esta es una función sobrecargada.

Véase también windowOpacity.

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

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

Nota: Funciónde configuración para la propiedad maximumSize.

Esta es una función sobrecargada.

Véase también maximumSize().

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

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

Nota: Funciónde configuración para la propiedad minimumSize.

Esta es una función sobrecargada.

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 desplaza a la posición (0, 0) en su nuevo padre.

Si el nuevo widget padre se encuentra en una ventana diferente, el widget al que se le ha cambiado el padre y sus hijos se añaden al final de la lista « tab chain » del nuevo widget padre, en el mismo orden interno que antes. Si alguno de los widgets movidos tenía el foco del teclado, setParent() llama a clearFocus() para ese widget.

Si el nuevo widget padre se encuentra en la misma ventana que el antiguo, al establecer el padre no se modifica el orden de tabulación ni el foco del teclado.

Si el «nuevo» widget padre es el antiguo, esta función no realiza ninguna acción.

Nota: El widget se vuelve invisible al cambiar su padre, incluso si antes estaba visible. Debes llamar a ` show()` para que el widget vuelva a ser visible.

Advertencia: Es muy poco probable que alguna vez necesites esta función. Si tienes un widget cuyo contenido cambia dinámicamente, es mucho más sencillo utilizar ` QStackedWidget`.

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

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

Esta función también admite como argumento indicadores de widget, f.

Se trata de una función sobrecargada.

void QWidget::setScreen(QScreen *screen)

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

La configuración de la pantalla solo tiene sentido para ventanas. Si es necesario, la ventana del widget se volverá a crear en screen.

Nota: Si la pantalla forma parte de un escritorio virtual con varias pantallas, la ventana no se desplazará automáticamente a screen. Para colocar la ventana en relación con la pantalla, utiliza la posición topLeft() de la pantalla.

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 atajo con el id especificado; 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 atajo con el id indicado; 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 y 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() y releaseShortcut().

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

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

Nota: Funciónde asignación para la propiedad sizeIncrement.

Esta es una función sobrecargada.

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 ajuste estándar y sin adaptación de altura a la anchura.

Nota: Funciónde asignación para la propiedad sizePolicy.

Esta es una función sobrecargada.

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

void QWidget::setStyle(QStyle *style)

Establece el estilo de la interfaz gráfica de usuario del widget en style. La propiedad del objeto de estilo no se transfiere.

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

Establecer el estilo de un widget no tiene ningún efecto sobre los widgets hijos existentes o futuros.

Advertencia: Esta función resulta especialmente útil con fines de demostración, cuando se desea mostrar las capacidades de estilo de Qt. En aplicaciones reales se debe evitar su uso y, en su lugar, emplear un estilo de interfaz gráfica de usuario coherente.

Véase 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 enfoque.

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

Ten en cuenta que, dado que se modifica el orden de tabulación del widget second, debes ordenar la cadena de esta forma:

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

yno 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 tienen un proxy de foco, setTabOrder() sustituye correctamente el proxy.

Nota: A partir de Qt 5.10: un widget que tiene un elemento hijo como proxy de foco se considera un widget compuesto. Al establecer el orden de tabulación entre uno o dos widgets compuestos, se conservará el orden de tabulación local dentro de cada uno de ellos. Esto significa que, si ambos widgets son compuestos, el orden de tabulación resultante irá desde el último elemento secundario dentro de first hasta el primer elemento secundario dentro de second.

Véase también setFocusPolicy(), setFocusProxy() y «Foco del teclado en widgets».

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

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

En lugar de configurar cada par manualmente de esta forma:

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 a:

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

La llamada no crea un bucle cerrado de foco de tabulación. Si hay más widgets con la política de foco « Qt::TabFocus », al pulsar la tecla de tabulación en ` d ` el foco se desplazará a uno de esos widgets, y no volverá a ` a`.

Se trata de una función sobrecargada.

Esta función se introdujo en Qt 6.6.

Véase también setFocusPolicy(), setFocusProxy() y «Foco del teclado en widgets».

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

Establece el indicador de ventana « flag » en este widget si « on » es verdadero; en caso contrario, desactiva el indicador.

Nota: Esta función llama a ` setParent()` al modificar los indicadores de una ventana, lo que provoca que el widget quede oculto. Debes llamar a ` show()` para que el widget vuelva a estar visible.

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

void QWidget::setWindowRole(const QString &role)

Establece la función de la ventana en « role ». Esto solo 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 mediante la operación OR de « Qt::WindowState »: « Qt::WindowMinimized », « Qt::WindowMaximized », « Qt::WindowFullScreen » y « Qt::WindowActive ».

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

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

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

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

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

Nota: En algunos sistemas de ventanas, ` Qt::WindowActive ` no es inmediato y puede ignorarse en determinados casos.

Cuando cambia el estado de la ventana, el widget recibe una llamada a ` 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 objeto ` widget` especificado.

Nota: Esta función está disponible con los widgets que se derivan de descripciones de interfaz de usuario creadas mediante uic.

Véase también «Cómo utilizar un archivo de interfaz de usuario de Qt Widgets Designer en su aplicación».

[slot] void QWidget::show()

Muestra el widget y sus widgets secundarios.

En el caso de las ventanas secundarias, esto equivale a llamar a ` setVisible(true)`. En los demás casos, equivale a llamar a ` showFullScreen()`, ` showMaximized()` o ` setVisible(true)`, dependiendo del comportamiento predeterminado de la plataforma para los indicadores de ventana.

Véase también raise(), showEvent(), hide(), setVisible(), showMinimized(), showMaximized(), showNormal(), isVisible() y windowFlags().

[virtual protected] void QWidget::showEvent(QShowEvent *event)

Este controlador de eventos se puede reimplementar en una subclase para recibir eventos de visualización de widgets que se pasan en el parámetro ` event `.

Los eventos de visualización no espontáneos se envían a los widgets inmediatamente antes de que se muestren. Los eventos de visualización espontáneos de las ventanas se envían posteriormente.

Nota: Un widget recibe eventos espontáneos de visualización y ocultación cuando el sistema de ventanas cambia su estado de asignación; por ejemplo, un evento espontáneo de ocultación cuando el usuario minimiza la ventana, y un evento espontáneo de visualización cuando la ventana se restaura de nuevo. Tras recibir un evento espontáneo de ocultación, el widget sigue considerándose visible en el sentido de ` isVisible()`.

Véanse también visible, event() y QShowEvent.

[slot] void QWidget::showFullScreen()

Muestra el widget en modo de pantalla completa.

La llamada a esta función solo afecta a ` windows`.

Para salir del modo de pantalla completa, llama a ` showNormal()` o a ` close()`.

Nota: El modode pantalla completa funciona correctamente en Windows, pero presenta ciertos problemas en X. Estos problemas se deben a las limitaciones del protocolo ICCCM, que especifica la comunicación entre los clientes X11 y el gestor de ventanas. ICCCM simplemente no entiende el concepto de ventanas a pantalla completa sin bordes. Por lo tanto, lo mejor que se puede hacer es solicitar una ventana sin bordes y colocarla y redimensionarla para que ocupe toda la pantalla. Dependiendo del gestor de ventanas, esto puede funcionar o no. La ventana sin bordes se solicita mediante las indicaciones MOTIF, que son compatibles, al menos parcialmente, con prácticamente todos los gestores de ventanas modernos.

Una alternativa sería prescindir por completo del gestor de ventanas y crear una ventana con el indicador « Qt::X11BypassWindowManagerHint ». Sin embargo, esto conlleva otros problemas graves, como fallos en el enfoque del teclado y efectos muy extraños al cambiar de escritorio o cuando el usuario abre otras ventanas.

Los gestores de ventanas X11 que siguen las especificaciones modernas posteriores a ICCCM admiten correctamente el modo de pantalla completa.

En macOS, mostrar una ventana a pantalla completa pone toda la aplicación en modo de pantalla completa, proporcionándole un escritorio dedicado. Mostrar otra ventana mientras la aplicación se ejecuta en modo de pantalla completa podría hacer que esa ventana también pasara automáticamente a pantalla completa. Para evitarlo, sal del modo de pantalla completa llamando a ` showNormal()` o a ` close()` en la ventana a pantalla completa antes de mostrar otra ventana.

Véanse también showNormal(), showMaximized(), show(), isVisible() y close().

[slot] void QWidget::showMaximized()

Muestra el widget maximizado.

La llamada a esta función solo afecta a windows.

En X11, es posible que esta función no funcione correctamente con determinados gestores de ventanas. Consulta la documentación sobre geometría de ventanas para obtener más información.

Véanse también setWindowState(), showNormal(), showMinimized(), show(), hide() y isVisible().

[slot] void QWidget::showMinimized()

Muestra el widget minimizado, en forma de icono.

La llamada a esta función solo afecta a windows.

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

[slot] void QWidget::showNormal()

Restaura el widget después de que se haya maximizado o minimizado.

La llamada a esta función solo afecta a windows.

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

void QWidget::stackUnder(QWidget *w)

Coloca el widget debajo de « w » en la pila del widget padre.

Para que esto funcione, el propio widget y w deben ser hermanos.

Véase también « raise()» y « lower()».

QStyle *QWidget::style() const

Véase también QWidget::setStyle(), QApplication::setStyle() y QApplication::style().

[virtual protected] void QWidget::tabletEvent(QTabletEvent *event)

Este controlador de eventos, para el evento event, puede reimplementarse en una subclase para recibir eventos de tableta para el widget.

Si reimplementas este controlador, es muy importante que « ignore() » el evento si no lo gestionas, para que el widget padre pueda interpretarlo.

La implementación predeterminada ignora el evento.

Si el seguimiento de la tableta está desactivado, los eventos de movimiento de la tableta solo se producen si el lápiz está en contacto con la tableta, o si se pulsa al menos un botón del lápiz, mientras se mueve el lápiz. Si el seguimiento de la tableta está activado, los eventos de movimiento de la tableta se producen incluso cuando el lápiz se encuentra cerca de la tableta, sin que se pulse ningún botón.

Véase también QEvent::ignore(), QEvent::accept(), event(), setTabletTracking() y QTabletEvent.

bool QWidget::testAttribute(Qt::WidgetAttribute attribute) const

Devuelve « true » si el atributo « attribute » está activado en este widget; en caso contrario, devuelve « false ».

Véase también setAttribute().

bool QWidget::underMouse() const

Devuelve « true » si el widget se encuentra debajo del cursor del ratón; en caso contrario, devuelve « false ».

Este valor no se actualiza correctamente durante las operaciones de arrastrar y soltar.

Véase también enterEvent() y leaveEvent().

void QWidget::ungrabGesture(Qt::GestureType gesture)

Da de baja el widget de un tipo determinado de gesture

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

[slot] void QWidget::update()

Actualiza el widget, salvo que las actualizaciones estén desactivadas o el widget esté oculto.

Esta función no provoca un redibujado inmediato; en su lugar, programa un evento de dibujo para que se procese cuando Qt vuelva al bucle de eventos principal. Esto permite a Qt optimizar el rendimiento para obtener mayor velocidad y menos parpadeo que con una llamada a ` repaint()`.

Llamar a `update()` varias veces suele dar lugar a una sola llamada a ` paintEvent()`.

Qt suele borrar el área del widget antes de la llamada a ` paintEvent()`. Si se establece el atributo del widget ` Qt::WA_OpaquePaintEvent `, el widget se encarga de pintar todos sus píxeles con un color opaco.

Nota: Esta ranura está sobrecargada. Para conectarse a esta ranura:

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

// Or using a lambda as wrapper:
connect(sender, &SenderClass::signal,
        widget, [receiver = widget]() { receiver->update(); });
Para ver más ejemplos y enfoques, consulta «Conexión a ranuras sobrecargadas».

Véase también « repaint()», « paintEvent()», « setUpdatesEnabled()» y «Analog Clock».

void QWidget::update(const QRect &rect)

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

Se trata de una función sobrecargada.

void QWidget::update(const QRegion &rgn)

Esta versión actualiza la visualización de una región rgn dentro del widget.

Se trata de una función sobrecargada.

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

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

Se trata de una función sobrecargada.

void QWidget::updateGeometry()

Notifica al sistema de diseño que este widget ha cambiado y que es posible que tenga que modificar su geometría.

Llama a esta función si han cambiado los valores de ` sizeHint()` o ` sizePolicy()`.

En el caso de los widgets ocultos explícitamente, updateGeometry() no realiza ninguna operación. Se notificará al sistema de diseño tan pronto como se muestre el widget.

[protected slot] void QWidget::updateMicroFocus(Qt::InputMethodQuery query = Qt::ImQueryAll)

Actualiza el microenfoque del widget e informa a los métodos de entrada de que ha cambiado el estado especificado por « query ».

QRegion QWidget::visibleRegion() const

Devuelve la región no ocultada en la que pueden producirse eventos de pintura.

En el caso de los widgets visibles, se trata de una aproximación del área no cubierta por otros widgets; en caso contrario, se trata de una región vacía.

La función ` repaint()` llama a esta función si es necesario, por lo que, en general, no es necesario que la llames.

[virtual protected] void QWidget::wheelEvent(QWheelEvent *event)

Este controlador de eventos, para el evento « event », puede reimplementarse en una subclase para recibir eventos de la rueda del widget.

Si reimplementas este controlador, es muy importante que « ignore() » el evento si no lo gestionas, para que el padre del widget pueda interpretarlo.

La implementación por defecto ignora el evento.

Véase también QEvent::ignore(), QEvent::accept(), event() y QWheelEvent.

WId QWidget::winId() const

Devuelve el identificador del sistema de ventanas del widget.

En principio es portátil, pero si lo utilizas, probablemente estés a punto de hacer algo que no lo sea. Ten cuidado.

Si un widget no es nativo (externo) y se invoca winId() sobre él, a ese widget se le proporcionará un identificador nativo.

Este valor puede cambiar en tiempo de ejecución. Tras un cambio en el identificador del sistema de ventanas, se enviará al widget un evento de tipo « QEvent::WinIdChange ».

Véase también find().

QWidget *QWidget::window() const

Devuelve la ventana de este widget, es decir, el siguiente widget antecesor que tenga (o pueda tener) un marco del sistema de ventanas.

Si el widget es una ventana, se devuelve el propio widget.

Un uso habitual es cambiar el título de la ventana:

aWidget->window()->setWindowTitle("New Window Title");

Véase también isWindow().

QWindow *QWidget::windowHandle() const

Si se trata de un widget nativo, devuelve el ` QWindow` asociado. En caso contrario, devuelve `null`.

Los widgets nativos incluyen los widgets de nivel superior, QGLWidget y los widgets hijos en los que se ha llamado a winId().

Véanse también winId() y screen().

[signal] void QWidget::windowIconChanged(const QIcon &icon)

Esta señal se emite cuando cambia el icono de la ventana, con el nuevo ` icon ` como argumento.

Nota: Señalde notificación para la propiedad windowIcon.

QString QWidget::windowRole() const

Devuelve el rol de la ventana o una cadena vacía.

Véase también setWindowRole(), windowIcon y windowTitle.

Qt::WindowStates QWidget::windowState() const

Devuelve el estado actual de la ventana. El estado de la ventana es una combinación mediante la operación OR de Qt::WindowState: Qt::WindowMinimized, Qt::WindowMaximized, Qt::WindowFullScreen y Qt::WindowActive.

Véanse también Qt::WindowState y setWindowState().

[signal] void QWidget::windowTitleChanged(const QString &title)

Esta señal se emite cuando cambia el título de la ventana, con el nuevo ` title ` como argumento.

Nota: Señalde notificación para la propiedad windowTitle.

Qt::WindowType QWidget::windowType() const

Devuelve el tipo de ventana de este widget. Es idéntico a windowFlags() y Qt::WindowType_Mask.

Véase también windowFlags.

Documentación de macros

QWIDGETSIZE_MAX

Define el tamaño máximo de un objeto ` QWidget `.

El tamaño máximo permitido para un widget es QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX), es decir, QSize (16777215, 16777215).

Véase también QWidget::setMaximumSize().

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