QMainWindow Class
La clase QMainWindow proporciona una ventana principal para la aplicación. Más información...
| Encabezado: | #include <QMainWindow> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake: | QT += widgets |
| Heredado de: | QWidget |
Tipos públicos
| enum | DockOption { AnimatedDocks, AllowNestedDocks, AllowTabbedDocks, ForceTabbedDocks, VerticalTabs, GroupedDragging } |
| flags | DockOptions |
Propiedades
|
|
Funciones públicas
| QMainWindow(QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags()) | |
| virtual | ~QMainWindow() |
| void | addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget) |
| void | addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget, Qt::Orientation orientation) |
| void | addToolBar(Qt::ToolBarArea area, QToolBar *toolbar) |
| void | addToolBar(QToolBar *toolbar) |
| QToolBar * | addToolBar(const QString &title) |
| void | addToolBarBreak(Qt::ToolBarArea area = Qt::TopToolBarArea) |
| QWidget * | centralWidget() const |
| Qt::DockWidgetArea | corner(Qt::Corner corner) const |
| virtual QMenu * | createPopupMenu() |
| QMainWindow::DockOptions | dockOptions() const |
| Qt::DockWidgetArea | dockWidgetArea(QDockWidget *dockwidget) const |
| bool | documentMode() const |
| QSize | iconSize() const |
| void | insertToolBar(QToolBar *before, QToolBar *toolbar) |
| void | insertToolBarBreak(QToolBar *before) |
| bool | isAnimated() const |
| bool | isDockNestingEnabled() const |
| QMenuBar * | menuBar() const |
| QWidget * | menuWidget() const |
| void | removeDockWidget(QDockWidget *dockwidget) |
| void | removeToolBar(QToolBar *toolbar) |
| void | removeToolBarBreak(QToolBar *before) |
| void | resizeDocks(const QList<QDockWidget *> &docks, const QList<int> &sizes, Qt::Orientation orientation) |
| bool | restoreDockWidget(QDockWidget *dockwidget) |
| bool | restoreState(const QByteArray &state, int version = 0) |
| QByteArray | saveState(int version = 0) const |
| void | setCentralWidget(QWidget *widget) |
| void | setCorner(Qt::Corner corner, Qt::DockWidgetArea area) |
| void | setDockOptions(QMainWindow::DockOptions options) |
| void | setDocumentMode(bool enabled) |
| void | setIconSize(const QSize &iconSize) |
| void | setMenuBar(QMenuBar *menuBar) |
| void | setMenuWidget(QWidget *menuBar) |
| void | setStatusBar(QStatusBar *statusbar) |
| void | setTabPosition(Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition) |
| void | setTabShape(QTabWidget::TabShape tabShape) |
| void | setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle) |
| void | splitDockWidget(QDockWidget *first, QDockWidget *second, Qt::Orientation orientation) |
| QStatusBar * | statusBar() const |
| QTabWidget::TabPosition | tabPosition(Qt::DockWidgetArea area) const |
| QTabWidget::TabShape | tabShape() const |
| QList<QDockWidget *> | tabifiedDockWidgets(QDockWidget *dockwidget) const |
| void | tabifyDockWidget(QDockWidget *first, QDockWidget *second) |
| QWidget * | takeCentralWidget() |
| Qt::ToolBarArea | toolBarArea(const QToolBar *toolbar) const |
| bool | toolBarBreak(QToolBar *toolbar) const |
| Qt::ToolButtonStyle | toolButtonStyle() const |
| bool | unifiedTitleAndToolBarOnMac() const |
Ranuras públicas
| void | setAnimated(bool enabled) |
| void | setDockNestingEnabled(bool enabled) |
| void | setUnifiedTitleAndToolBarOnMac(bool set) |
Señales
| void | iconSizeChanged(const QSize &iconSize) |
| void | tabifiedDockWidgetActivated(QDockWidget *dockWidget) |
| void | toolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle) |
Funciones protegidas reimplementadas
| virtual void | contextMenuEvent(QContextMenuEvent *event) override |
| virtual bool | event(QEvent *event) override |
Descripción detallada
Marco de trabajo de la ventana principal de Qt
Una ventana principal proporciona un marco para crear la interfaz de usuario de una aplicación. Qt dispone de QMainWindow y sus clases relacionadas para la gestión de la ventana principal. QMainWindow tiene su propio diseño, al que se pueden añadir « QToolBar», « QDockWidget», un « QMenuBar » y un « QStatusBar ». El diseño cuenta con un área central que puede ser ocupada por cualquier tipo de widget. A continuación se muestra una imagen del diseño.

Creación de componentes de la ventana principal
Un widget central suele ser un widget estándar de Qt, como un QTextEdit o un QGraphicsView. También se pueden utilizar widgets personalizados para aplicaciones avanzadas. El widget central se configura mediante setCentralWidget().
Las ventanas principales pueden tener una interfaz de documento único (SDI) o múltiple (MDI). Para crear aplicaciones MDI en Qt, se utiliza un ` QMdiArea ` como widget central.
A continuación, examinaremos cada uno de los demás widgets que se pueden añadir a una ventana principal. Ofrecemos ejemplos sobre cómo crearlos y añadirlos.
Creación de menús
Qt implementa los menús en ` QMenu ` y `QMainWindow` los almacena en un ` QMenuBar`. Los elementos de menú (` QAction`) se añaden a los menús, que los muestran como elementos de menú.
Puedes añadir nuevos menús a la barra de menús de la ventana principal llamando a ` menuBar()`, que devuelve el ` QMenuBar ` de la ventana, y a continuación añadir un menú con ` QMenuBar::addMenu()`.
QMainWindow incluye una barra de menús por defecto, pero también puedes configurar una tú mismo con ` setMenuBar()`. Si deseas implementar una barra de menús personalizada (es decir, no utilizar el widget ` QMenuBar `), puedes configurarla con ` setMenuWidget()`.
A continuación se muestra un ejemplo de cómo crear menús:
void MainWindow::createMenus()
{
fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(newAct);
fileMenu->addAction(openAct);
fileMenu->addAction(saveAct);La función createPopupMenu() crea menús emergentes cuando la ventana principal recibe eventos de menú contextual. La implementación predeterminada genera un menú con las acciones marcables de los widgets del dock y las barras de herramientas. Puedes reimplementar createPopupMenu() para crear un menú personalizado.
Creación de barras de herramientas
Las barras de herramientas se implementan en la clase ` QToolBar `. Para añadir una barra de herramientas a una ventana principal, se utiliza ` addToolBar()`.
La posición inicial de las barras de herramientas se controla asignándolas a un objeto ` Qt::ToolBarArea` específico. Se puede dividir un área insertando un salto de barra de herramientas —piensa en ello como un salto de línea en la edición de texto— con ` addToolBarBreak() ` o ` insertToolBarBreak()`. También se puede restringir la colocación por parte del usuario con ` QToolBar::setAllowedAreas()` y ` QToolBar::setMovable()`.
El tamaño de los iconos de la barra de herramientas se puede obtener con iconSize(). Los tamaños dependen de la plataforma; se puede establecer un tamaño fijo con setIconSize(). Se puede modificar el aspecto de todos los botones de la barra de herramientas con setToolButtonStyle().
A continuación se muestra un ejemplo de creación de una barra de herramientas:
void MainWindow::createToolBars()
{
fileToolBar = addToolBar(tr("File"));
fileToolBar->addAction(newAct);Creación de widgets acoplables
Los widgets acoplables se implementan en la clase QDockWidget. Un widget acoplable es una ventana que se puede acoplar a la ventana principal. Los widgets acoplables se añaden a una ventana principal mediante addDockWidget().
Existen cuatro áreas de widgets acoplables, tal y como se indica en la enumeración ` Qt::DockWidgetArea `: izquierda, derecha, superior e inferior. Se puede especificar qué área de widgets acoplables debe ocupar las esquinas donde las áreas se solapan mediante ` setCorner()`. Por defecto, cada área solo puede contener una fila (vertical u horizontal) de widgets acoplables, pero si se habilita el anidamiento con ` setDockNestingEnabled()`, se pueden añadir widgets acoplables en cualquier dirección.
También se pueden apilar dos widgets acoplados uno encima del otro. En ese caso, se utiliza un control « QTabBar » para seleccionar cuál de los widgets debe mostrarse.
A continuación ofrecemos un ejemplo de cómo crear y añadir widgets de acoplamiento a una ventana principal:
QDockWidget *dockWidget = new QDockWidget(tr("Dock Widget"), this);
dockWidget->setAllowedAreas(Qt::LeftDockWidgetArea |
Qt::RightDockWidgetArea);
dockWidget->setWidget(dockWidgetContents);
addDockWidget(Qt::LeftDockWidgetArea, dockWidget);La barra de estado
Se puede configurar una barra de estado con ` setStatusBar()`, pero se crea una la primera vez que se llama a ` statusBar() ` (que devuelve la barra de estado de la ventana principal). Consulte ` QStatusBar ` para obtener información sobre cómo utilizarla.
Almacenamiento del estado
QMainWindow puede almacenar el estado de su diseño mediante ` saveState()`; posteriormente, se puede recuperar con ` restoreState()`. Lo que se almacena es la posición y el tamaño (en relación con el tamaño de la ventana principal) de las barras de herramientas y los widgets acoplables.
Consideraciones de seguridad
La función ` restoreState()` deserializa un blob binario versionado que describe el diseño de las barras de herramientas y los widgets acoplables, incluida una estructura de árbol anidada de forma recursiva para las áreas acoplables divididas y con pestañas. Se validan el marcador mágico y la versión del formato, pero los campos individuales —como los índices de las áreas acopladas y la profundidad del árbol de diseño anidado— no se comprueban respecto a los límites de la configuración real de la ventana principal una vez aceptada la estructura externa.
Solo se debe pasar a ` restoreState()` un ` QByteArray ` que haya sido generado previamente por ` saveState()` y guardado por la misma versión, o una compatible, de tu aplicación, normalmente a través de ` QSettings`. No llames a ` restoreState()` con datos de origen desconocido o no fiable, como un archivo descargado de la red, un archivo de configuración sincronizado o compartido, o datos proporcionados por otra aplicación que pueda estar comprometida.
Véase también QMenuBar, QToolBar, QStatusBar, QDockWidget y el ejemplo de menús.
Documentación sobre los tipos de miembro
enum QMainWindow::DockOption
flags QMainWindow::DockOptions
Esta enumeración contiene indicadores que especifican el comportamiento de acoplamiento de QMainWindow.
| Constante | Valor | Descripción |
|---|---|---|
QMainWindow::AnimatedDocks | 0x01 | Idéntico a la propiedad animated. |
QMainWindow::AllowNestedDocks | 0x02 | Idéntico a la propiedad ` dockNestingEnabled `. |
QMainWindow::AllowTabbedDocks | 0x04 | El usuario puede soltar un widget de acoplamiento «encima» de otro. Los dos widgets se apilan y aparece una barra de pestañas para seleccionar cuál de ellos está visible. |
QMainWindow::ForceTabbedDocks | 0x08 | Cada área de acoplamiento contiene una única pila de widgets de acoplamiento con pestañas. En otras palabras, los widgets de acoplamiento no pueden colocarse uno al lado del otro en una misma área de acoplamiento. Si se activa esta opción, AllowNestedDocks no tiene ningún efecto. |
QMainWindow::VerticalTabs | 0x10 | Las dos áreas de acoplamiento verticales situadas a los lados de la ventana principal muestran sus pestañas en vertical. Si esta opción no está activada, todas las áreas de acoplamiento muestran sus pestañas en la parte inferior. Implica AllowTabbedDocks. Véase también setTabPosition(). |
QMainWindow::GroupedDragging | 0x20 | Al arrastrar la barra de título de un dock, se arrastrarán todas las pestañas asociadas a él. Implica AllowTabbedDocks. No funciona bien si algunos QDockWidgets tienen restricciones en cuanto al área en la que se les permite aparecer. (Este valor de enumeración se añadió en Qt 5.6.) |
Estas opciones solo controlan cómo se pueden soltar los widgets de dock en un ` QMainWindow`. No reorganizan los widgets de dock para que se ajusten a las opciones especificadas. Por este motivo, deben configurarse antes de añadir cualquier widget de dock a la ventana principal. Las excepciones a esto son las opciones `AnimatedDocks` y `VerticalTabs`, que pueden configurarse en cualquier momento.
El tipo `DockOptions` es una definición de tipo (`typedef`) para ` QFlags<DockOption>`. Almacena una combinación OR de valores de `DockOption`.
Documentación de propiedades
animated : bool
Esta propiedad determina si la manipulación de los widgets acoplables y las barras de herramientas se realiza de forma animada
Cuando se arrastra un widget acoplable o una barra de herramientas sobre la ventana principal, esta ajusta su contenido para indicar dónde se acoplará dicho widget o barra de herramientas si se suelta. Al activar esta propiedad, QMainWindow desplaza su contenido mediante una animación fluida. Al desactivar esta propiedad, el contenido se ajusta de golpe a sus nuevas posiciones.
Por defecto, esta propiedad está activada. Se puede desactivar si la ventana principal contiene widgets que tardan en cambiar de tamaño o en actualizarse.
Establecer esta propiedad es idéntico a activar la opción « AnimatedDocks » mediante la función ` setDockOptions()`.
Funciones de acceso:
| bool | isAnimated() const |
| void | setAnimated(bool enabled) |
dockNestingEnabled : bool
Esta propiedad determina si los muelles se pueden anidar
Si esta propiedad tiene el valor « false », las áreas de acoplamiento solo pueden contener una única fila (horizontal o vertical) de widgets de acoplamiento. Si esta propiedad tiene el valor « true », el espacio ocupado por un widget de acoplamiento se puede dividir en cualquier dirección para albergar más widgets de acoplamiento.
El anidamiento de acoplamientos solo es necesario en aplicaciones que contienen muchos widgets de acoplamiento. Ofrece al usuario mayor libertad a la hora de organizar su ventana principal. Sin embargo, el anidamiento de acoplamientos da lugar a un comportamiento más complejo (y menos intuitivo) cuando se arrastra un widget de acoplamiento sobre la ventana principal, ya que hay más formas en las que un widget de acoplamiento soltado puede colocarse en el área de acoplamiento.
Establecer esta propiedad es idéntico a configurar la opción « AllowNestedDocks » mediante la función ` setDockOptions()`.
Funciones de acceso:
| bool | isDockNestingEnabled() const |
| void | setDockNestingEnabled(bool enabled) |
dockOptions : DockOptions
Esta propiedad determina el comportamiento de acoplamiento de QMainWindow
El valor por defecto es AnimatedDocks | AllowTabbedDocks.
Funciones de acceso:
| QMainWindow::DockOptions | dockOptions() const |
| void | setDockOptions(QMainWindow::DockOptions options) |
documentMode : bool
Esta propiedad indica si la barra de pestañas de los widgets acoplables con pestañas está configurada en modo documento.
El valor por defecto es «false».
Funciones de acceso:
| bool | documentMode() const |
| void | setDocumentMode(bool enabled) |
Véase también ` QTabBar::documentMode`.
iconSize : QSize
Tamaño de los iconos de la barra de herramientas en esta ventana principal.
El valor por defecto es el tamaño predeterminado de los iconos de la barra de herramientas del estilo de la interfaz gráfica de usuario. Ten en cuenta que los iconos utilizados deben tener, como mínimo, este tamaño, ya que solo se reducen a escala.
Funciones de Access:
| QSize | iconSize() const |
| void | setIconSize(const QSize &iconSize) |
tabShape : QTabWidget::TabShape
Esta propiedad define la forma de la pestaña que se utiliza en los widgets acoplables con pestañas.
El valor predeterminado es QTabWidget::Rounded.
Funciones de acceso:
| QTabWidget::TabShape | tabShape() const |
| void | setTabShape(QTabWidget::TabShape tabShape) |
Véase también setTabPosition().
toolButtonStyle : Qt::ToolButtonStyle
Estilo de los botones de la barra de herramientas en esta ventana principal.
Para que el estilo de los botones de la barra de herramientas se ajuste a la configuración del sistema, establece esta propiedad en Qt::ToolButtonFollowStyle. En Unix, se utilizará la configuración del usuario del entorno de escritorio. En otras plataformas, Qt::ToolButtonFollowStyle significa «solo icono».
El valor por defecto es « Qt::ToolButtonIconOnly ».
Funciones de acceso:
| Qt::ToolButtonStyle | toolButtonStyle() const |
| void | setToolButtonStyle(Qt::ToolButtonStyle toolButtonStyle) |
unifiedTitleAndToolBarOnMac : bool
Esta propiedad se mantiene independientemente de si la ventana utiliza el aspecto unificado del título y la barra de herramientas en macOS
Ten en cuenta que la implementación de Qt 5 presenta varias limitaciones en comparación con Qt 4:
- No se admite su uso en ventanas con contenido OpenGL. Esto incluye QOpenGLWidget.
- El uso de barras de herramientas acoplables o movibles puede provocar errores de renderizado y no se recomienda
Funciones de acceso:
| bool | unifiedTitleAndToolBarOnMac() const |
| void | setUnifiedTitleAndToolBarOnMac(bool set) |
Documentación de funciones miembro
[explicit] QMainWindow::QMainWindow(QWidget *parent = nullptr, Qt::WindowFlags flags = Qt::WindowFlags())
Crea una ventana QMainWindow con el indicador « parent » proporcionado y el widget especificado « flags ».
QMainWindow establece por sí misma el indicador « Qt::Window », por lo que siempre se creará como un widget de nivel superior.
[virtual noexcept] QMainWindow::~QMainWindow()
Cierra la ventana principal.
void QMainWindow::addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget)
Añade el elemento « dockwidget » indicado a la sección « area » especificada en la ventana principal.
void QMainWindow::addDockWidget(Qt::DockWidgetArea area, QDockWidget *dockwidget, Qt::Orientation orientation)
Añade dockwidget a la dirección area, en la dirección especificada por orientation.
void QMainWindow::addToolBar(Qt::ToolBarArea area, QToolBar *toolbar)
Añade el « toolbar » a la barra de herramientas especificada « area » en esta ventana principal. El « toolbar » se coloca al final del bloque actual de la barra de herramientas (es decir, de la línea). Si la ventana principal ya gestiona el « toolbar », solo moverá la barra de herramientas a « area ».
Véase también insertToolBar(), addToolBarBreak() y insertToolBarBreak().
void QMainWindow::addToolBar(QToolBar *toolbar)
Equivalente a llamar a addToolBar(Qt::TopToolBarArea, toolbar)
Esta es una función sobrecargada.
QToolBar *QMainWindow::addToolBar(const QString &title)
Crea un objeto ` QToolBar `, establece el título de su ventana como ` title` y lo inserta en la zona superior de la barra de herramientas.
Esta es una función sobrecargada.
Véase también setWindowTitle().
void QMainWindow::addToolBarBreak(Qt::ToolBarArea area = Qt::TopToolBarArea)
Añade un salto de barra de herramientas a la barra de herramientas « area » indicada, después de todos los demás objetos presentes.
QWidget *QMainWindow::centralWidget() const
Devuelve el widget central de la ventana principal. Esta función devuelve un objeto de tipo « nullptr » si no se ha establecido el widget central.
Véase también ` setCentralWidget()`.
[override virtual protected] void QMainWindow::contextMenuEvent(QContextMenuEvent *event)
Reimplementa: QWidget::contextMenuEvent(QContextMenuEvent *event).
Qt::DockWidgetArea QMainWindow::corner(Qt::Corner corner) const
Devuelve el área del widget del dock que ocupa el corner especificado.
Véase también setCorner().
[virtual] QMenu *QMainWindow::createPopupMenu()
Devuelve un menú emergente que contiene elementos seleccionables para las barras de herramientas y los widgets acoplados presentes en la ventana principal. Si no hay barras de herramientas ni widgets acoplados, esta función devuelve ` nullptr`.
Por defecto, la ventana principal invoca esta función cuando el usuario activa un menú contextual, normalmente haciendo clic con el botón derecho del ratón sobre una barra de herramientas o un widget acoplado.
Si deseas crear un menú emergente personalizado, reimplementa esta función y devuelve un menú emergente de nueva creación. La propiedad del menú emergente se transfiere al llamante.
Véase también addDockWidget(), addToolBar() y menuBar().
Qt::DockWidgetArea QMainWindow::dockWidgetArea(QDockWidget *dockwidget) const
Devuelve el objeto ` Qt::DockWidgetArea ` correspondiente a ` dockwidget`. Si ` dockwidget ` no se ha añadido a la ventana principal, esta función devuelve ` Qt::NoDockWidgetArea`.
Véase también addDockWidget(), splitDockWidget() y Qt::DockWidgetArea.
[override virtual protected] bool QMainWindow::event(QEvent *event)
Reimplementa: QWidget::event(QEvent *event).
[signal] void QMainWindow::iconSizeChanged(const QSize &iconSize)
Esta señal se emite cuando se modifica el tamaño de los iconos utilizados en la ventana. El nuevo tamaño de los iconos se transmite a través de la propiedad ` iconSize`.
Puedes conectar esta señal a otros componentes para ayudar a mantener una apariencia coherente en tu aplicación.
Véase también ` setIconSize()`.
void QMainWindow::insertToolBar(QToolBar *before, QToolBar *toolbar)
Inserta el elemento « toolbar » en el área ocupada por la barra de herramientas « before », de modo que aparezca antes que esta. Por ejemplo, en un diseño normal de izquierda a derecha, esto significa que « toolbar » aparecerá a la izquierda de la barra de herramientas especificada por « before » en un área de barra de herramientas horizontal.
Véase también insertToolBarBreak(), addToolBar() y addToolBarBreak().
void QMainWindow::insertToolBarBreak(QToolBar *before)
Inserta un salto de barra de herramientas antes de la barra de herramientas especificada por ` before`.
QMenuBar *QMainWindow::menuBar() const
Devuelve la barra de menús de la ventana principal. Esta función crea y devuelve una barra de menús vacía si esta no existe.
Si deseas que todas las ventanas de una aplicación para Mac compartan una misma barra de menús, no utilices esta función para crearla, ya que la barra de menús creada aquí tendrá como padre este objeto ` QMainWindow `. En su lugar, debes crear una barra de menús que no tenga padre, la cual podrás compartir entre todas las ventanas de Mac. Crea una barra de menús sin padre de la siguiente manera:
Véase también ` setMenuBar()`.
QWidget *QMainWindow::menuWidget() const
Devuelve la barra de menús de la ventana principal. Esta función devuelve «null» si aún no se ha creado la barra de menús.
Véase también setMenuWidget().
void QMainWindow::removeDockWidget(QDockWidget *dockwidget)
Elimina el elemento « dockwidget » del diseño de la ventana principal y lo oculta. Ten en cuenta que el elemento « dockwidget » no se elimina.
void QMainWindow::removeToolBar(QToolBar *toolbar)
Elimina el elemento « toolbar » de la disposición de la ventana principal y lo oculta. Ten en cuenta que el elemento « toolbar » no se elimina.
void QMainWindow::removeToolBarBreak(QToolBar *before)
Elimina un salto de barra de herramientas insertado previamente antes de la barra de herramientas especificada por ` before`.
void QMainWindow::resizeDocks(const QList<QDockWidget *> &docks, const QList<int> &sizes, Qt::Orientation orientation)
Ajusta el tamaño de los widgets del dock de la lista docks al tamaño correspondiente en píxeles de la lista sizes. Si orientation es Qt::Horizontal, ajusta la anchura; en caso contrario, ajusta la altura de los widgets del dock. Los tamaños se ajustarán de tal forma que se respeten los tamaños máximo y mínimo, y el propio QMainWindow no se redimensionará. Cualquier espacio adicional o que falte se distribuye entre los widgets según el peso relativo de sus tamaños.
Ejemplo:
resizeDocks({blueWidget, yellowWidget}, {20 , 40}, Qt::Horizontal);Si el widget azul y el amarillo están anidados en el mismo nivel, se redimensionarán de tal forma que el widget amarillo sea el doble de grande que el azul
Si algunos widgets están agrupados en pestañas, solo debe especificarse un widget por grupo. Los widgets que no figuren en la lista podrían modificarse para respetar las restricciones.
bool QMainWindow::restoreDockWidget(QDockWidget *dockwidget)
Restaura el estado de dockwidget si se ha creado tras la llamada a restoreState(). Devuelve true si se ha restaurado el estado; en caso contrario, devuelve false.
Véase también restoreState() y saveState().
bool QMainWindow::restoreState(const QByteArray &state, int version = 0)
Restaura la configuración « state » de las barras de herramientas y los widgets acoplables de esta ventana principal. También restaura la configuración de las esquinas. El número de « version » se compara con el almacenado en « state ». Si no coinciden, el estado de la ventana principal no se modifica y esta función devuelve « false »; en caso contrario, se restaura el estado y esta función devuelve « true ».
Para restaurar la geometría guardada mediante QSettings, puedes utilizar un código como este:
void MainWindow::readSettings()
{
QSettings settings("MyCompany", "MyApp");
restoreGeometry(settings.value("myWidget/geometry").toByteArray());
restoreState(settings.value("myWidget/windowState").toByteArray());
}Véase también « saveState()», « QWidget::saveGeometry()», « QWidget::restoreGeometry()» y « restoreDockWidget()».
QByteArray QMainWindow::saveState(int version = 0) const
Guarda el estado actual de las barras de herramientas y los widgets acoplables de esta ventana principal. Esto incluye la configuración de las esquinas, que se puede establecer mediante setCorner(). El número version se almacena como parte de los datos.
La propiedad ` objectName ` se utiliza para identificar cada ` QToolBar ` y ` QDockWidget`. Debes asegurarte de que esta propiedad sea única para cada ` QToolBar ` y ` QDockWidget ` que añadas a la QMainWindow
Para restaurar el estado guardado, pasa el valor de retorno y el número de version a restoreState().
Para guardar la geometría al cerrar la ventana, puede implementar un evento de cierre de la siguiente manera:
void MyMainWindow::closeEvent(QCloseEvent *event)
{
QSettings settings("MyCompany", "MyApp");
settings.setValue("geometry", saveGeometry());
settings.setValue("windowState", saveState());
QMainWindow::closeEvent(event);
}Véase también restoreState(), QWidget::saveGeometry() y QWidget::restoreGeometry().
void QMainWindow::setCentralWidget(QWidget *widget)
Establece el widget especificado como el widget central de la ventana principal.
Nota: ` QMainWindow ` asume la propiedad del puntero ` widget ` y lo elimina en el momento oportuno.
Véase también centralWidget().
void QMainWindow::setCorner(Qt::Corner corner, Qt::DockWidgetArea area)
Establece que el widget de dock indicado area ocupe el espacio especificado corner.
Véase también corner().
void QMainWindow::setMenuBar(QMenuBar *menuBar)
Establece la barra de menús de la ventana principal en « menuBar ».
Nota: ` QMainWindow ` toma la propiedad del puntero ` menuBar ` y lo elimina en el momento oportuno.
Véase también ` menuBar()`.
void QMainWindow::setMenuWidget(QWidget *menuBar)
Establece la barra de menús de la ventana principal en « menuBar ».
QMainWindow Toma posesión del puntero ` menuBar ` y lo elimina en el momento oportuno.
Véase también menuWidget().
void QMainWindow::setStatusBar(QStatusBar *statusbar)
Establece la barra de estado de la ventana principal en « statusbar ».
Al establecer la barra de estado en ` nullptr `, esta desaparecerá de la ventana principal. Ten en cuenta que ` QMainWindow ` toma el control del puntero ` statusbar ` y lo elimina en el momento oportuno.
Véase también statusBar().
void QMainWindow::setTabPosition(Qt::DockWidgetAreas areas, QTabWidget::TabPosition tabPosition)
Establece la posición de las pestañas del widget de acoplamiento areas en la posición especificada tabPosition. Por defecto, todas las áreas de acoplamiento muestran sus pestañas en la parte inferior.
Nota: La opción de dock VerticalTabs anula las posiciones de las pestañas establecidas por este método.
Véase también tabPosition() y setTabShape().
void QMainWindow::splitDockWidget(QDockWidget *first, QDockWidget *second, Qt::Orientation orientation)
Divide el espacio que ocupa el widget de acoplamiento « first » en dos partes, desplaza el widget de acoplamiento « first » a la primera parte y el widget de acoplamiento « second » a la segunda parte.
La opción « orientation » especifica cómo se divide el espacio: una división de tipo « Qt::Horizontal » coloca el segundo widget acoplado a la derecha del primero; una división de tipo « Qt::Vertical » coloca el segundo widget acoplado debajo del primero.
Nota: si first se encuentra actualmente en un área acoplada con pestañas, second se añadirá como una nueva pestaña, no como vecina de first. Esto se debe a que una sola pestaña solo puede contener un widget de acoplamiento.
Nota: El Qt::LayoutDirection influye en el orden de los widgets acoplados en las dos partes del área dividida. Cuando se habilita la dirección de diseño de derecha a izquierda, el orden de los widgets acoplados se invertirá.
Véase también tabifyDockWidget(), addDockWidget() y removeDockWidget().
QStatusBar *QMainWindow::statusBar() const
Devuelve la barra de estado de la ventana principal. Esta función crea y devuelve una barra de estado vacía si esta no existe.
Véase también setStatusBar().
QTabWidget::TabPosition QMainWindow::tabPosition(Qt::DockWidgetArea area) const
Devuelve la posición de la tabulación de « area ».
Nota: La opción « VerticalTabs » del dock anula las posiciones de las pestañas que devuelve esta función.
Véase también setTabPosition() y tabShape().
[signal] void QMainWindow::tabifiedDockWidgetActivated(QDockWidget *dockWidget)
Esta señal se emite cuando se activa el widget de dock con pestañas al seleccionar la pestaña. El widget de dock activado se pasa a través de ` dockWidget`.
Véase también tabifyDockWidget() y tabifiedDockWidgets().
QList<QDockWidget *> QMainWindow::tabifiedDockWidgets(QDockWidget *dockwidget) const
Devuelve los widgets del dock que se han agrupado en pestañas junto con dockwidget.
Véase también tabifyDockWidget().
void QMainWindow::tabifyDockWidget(QDockWidget *first, QDockWidget *second)
Mueve el widget de dock second sobre el widget de dock first, creando un área de dock con pestañas en la ubicación actual de first.
Ambos widgets de dock deben haberse añadido a la ventana principal con addDockWidget() antes de llamar a esta función, y ninguno de los dos puede tener pestañas ya.
Véase también tabifiedDockWidgets() y addDockWidget().
QWidget *QMainWindow::takeCentralWidget()
Elimina el widget central de esta ventana principal.
La propiedad del widget eliminado se transfiere a quien realiza la llamada.
Qt::ToolBarArea QMainWindow::toolBarArea(const QToolBar *toolbar) const
Devuelve el objeto ` Qt::ToolBarArea ` correspondiente a ` toolbar`. Si ` toolbar ` no se ha añadido a la ventana principal, esta función devuelve ` Qt::NoToolBarArea`.
Véase también addToolBar(), addToolBarBreak() y Qt::ToolBarArea.
bool QMainWindow::toolBarBreak(QToolBar *toolbar) const
Devuelve si hay un salto de barra de herramientas antes de toolbar.
Véase también addToolBarBreak() y insertToolBarBreak().
[signal] void QMainWindow::toolButtonStyleChanged(Qt::ToolButtonStyle toolButtonStyle)
Esta señal se emite cuando se cambia el estilo utilizado para los botones de herramientas de la ventana. El nuevo estilo se pasa en ` toolButtonStyle`.
Puedes conectar esta señal a otros componentes para ayudar a mantener una apariencia coherente en tu aplicación.
Véase también setToolButtonStyle().
© 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.