Ejemplo de menús
El ejemplo «Menús» muestra cómo se pueden utilizar los menús en una aplicación con ventana principal.
Un control de menú puede ser un menú desplegable en una barra de menús o un menú contextual independiente. Los menús desplegables aparecen en la barra de menús cuando el usuario hace clic en el elemento correspondiente o pulsa la tecla de acceso rápido especificada. Los menús contextuales suelen activarse mediante una tecla especial del teclado o haciendo clic con el botón derecho del ratón.

Un menú consta de una lista de elementos de acción. En las aplicaciones, muchos comandos habituales pueden activarse a través de menús, botones de la barra de herramientas o atajos de teclado. Dado que el usuario espera que los comandos se ejecuten de la misma manera, independientemente de la interfaz de usuario utilizada, resulta útil representar cada comando como una acción.
El ejemplo «Menús» consta de una única clase, ` MainWindow`, derivada de la clase ` QMainWindow `. Al seleccionar uno de los elementos de acción de nuestra aplicación, se mostrará la ruta del elemento en su widget central.
Definición de la clase MainWindow
QMainWindow proporciona una ventana principal de la aplicación, con una barra de menús, barras de herramientas, widgets acoplados y una barra de estado alrededor de un gran widget central.
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
MainWindow();
protected:
#ifndef QT_NO_CONTEXTMENU
void contextMenuEvent(QContextMenuEvent *event) override;
#endif // QT_NO_CONTEXTMENUEn este ejemplo, veremos cómo implementar menús desplegables, así como un menú contextual. Para implementar un menú contextual personalizado, debemos reimplementar la función contextMenuEvent() de QWidget para recibir los eventos del menú contextual de nuestra ventana principal.
private slots:
void newFile();
void open();
void save();
void print();
void undo();
void redo();
void cut();
void copy();
void paste();
void bold();
void italic();
void leftAlign();
void rightAlign();
void justify();
void center();
void setLineSpacing();
void setParagraphSpacing();
void about();
void aboutQt();También debemos implementar un conjunto de slots privados para responder cuando el usuario active cualquiera de nuestras entradas de menú. Ten en cuenta que estos slots no se incluyen en esta documentación, ya que son triviales; es decir, la mayoría de ellos solo muestran la ruta de la acción en el widget central de la ventana principal.
private:
void createActions();
void createMenus();Hemos optado por simplificar el constructor implementando dos funciones privadas de conveniencia para crear las distintas acciones, añadirlas a los menús e insertar los menús en la barra de menús de nuestra ventana principal.
QMenu *fileMenu;
QMenu *editMenu;
QMenu *formatMenu;
QMenu *helpMenu;
QActionGroup *alignmentGroup;
QAction *newAct;
QAction *openAct;
QAction *saveAct;
QAction *printAct;
QAction *exitAct;
QAction *undoAct;
QAction *redoAct;
QAction *cutAct;
QAction *copyAct;
QAction *pasteAct;
QAction *boldAct;
QAction *italicAct;
QAction *leftAlignAct;
QAction *rightAlignAct;
QAction *justifyAct;
QAction *centerAct;
QAction *setLineSpacingAct;
QAction *setParagraphSpacingAct;
QAction *aboutAct;
QAction *aboutQtAct;
QLabel *infoLabel;
};Por último, declaramos los distintos menús y acciones, así como una sencilla etiqueta informativa, en el ámbito de toda la aplicación.
La clase ` QMenu ` proporciona un widget de menú para su uso en barras de menú, menús contextuales y otros menús emergentes, mientras que la clase ` QAction ` proporciona una acción de interfaz de usuario abstracta que puede insertarse en widgets.
En algunas situaciones resulta útil agrupar acciones; por ejemplo, si tenemos una acción de « Left Align », una de « Right Align », una de « Justify » y una de « Center », y queremos que solo una de estas acciones esté activa en cada momento. Una forma sencilla de lograrlo es agrupar las acciones en un grupo de acciones utilizando la clase « QActionGroup ».
Implementación de la clase MainWindow
En el constructor, empezamos creando un ` QWidget ` normal y lo convertimos en el widget central de nuestra ventana principal. Ten en cuenta que la ventana principal asume la propiedad del puntero del widget y lo elimina en el momento adecuado.
MainWindow::MainWindow()
{
QWidget *widget = new QWidget;
setCentralWidget(widget);
QWidget *topFiller = new QWidget;
topFiller->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
infoLabel = new QLabel(tr("<i>Choose a menu option, or right-click to "
"invoke a context menu</i>"));
infoLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
infoLabel->setAlignment(Qt::AlignCenter);
QWidget *bottomFiller = new QWidget;
bottomFiller->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QVBoxLayout *layout = new QVBoxLayout;
layout->setContentsMargins(5, 5, 5, 5);
layout->addWidget(topFiller);
layout->addWidget(infoLabel);
layout->addWidget(bottomFiller);
widget->setLayout(layout);A continuación, creamos la etiqueta de información, así como un relleno superior e inferior, que añadimos a un diseño que instalamos en el widget central. Los objetos ` QMainWindow ` vienen con su propio diseño personalizado, y establecer un diseño en la propia ventana principal, o crear un diseño con una ventana principal como padre, se considera un error. En su lugar, siempre debes establecer tu propio diseño en el widget central.
createActions();
createMenus();
QString message = tr("A context menu is available by right-clicking");
statusBar()->showMessage(message);
setWindowTitle(tr("Menus"));
setMinimumSize(160, 160);
resize(480, 320);
}Para crear las acciones y los menús, llamamos a nuestras dos funciones de conveniencia: ` createActions() ` y ` createMenus()`. Volveremos sobre ellas en breve.
QMainWindowLa función ` statusBar()` devuelve la barra de estado de la ventana principal (si la barra de estado no existe, esta función creará y devolverá una barra de estado vacía). Inicializamos la barra de estado y el título de la ventana, redimensionamos la ventana a un tamaño adecuado y nos aseguramos de que la ventana principal no pueda redimensionarse a un tamaño menor que el establecido.
Ahora, echemos un vistazo más de cerca a la función de conveniencia ` createActions() `, que crea las distintas acciones:
void MainWindow::createActions()
{
newAct = new QAction(QIcon::fromTheme(QIcon::ThemeIcon::DocumentNew),
tr("&New"), this);
newAct->setShortcuts(QKeySequence::New);
newAct->setStatusTip(tr("Create a new file"));
connect(newAct, &QAction::triggered, this, &MainWindow::newFile);
...Un objeto ` QAction ` puede contener un icono, un texto, un atajo, una sugerencia de estado, un texto de «¿Qué es esto?» y una información sobre herramientas. La mayoría de estos elementos se pueden configurar en el constructor, pero también se pueden establecer de forma independiente utilizando las funciones de conveniencia proporcionadas.
En la función ` createActions() `, primero creamos una acción ` newAct `, pasando el texto y un icono mediante una de las constantes de iconos del tema. Establecemos ` Ctrl+N ` como su atajo mediante la función ` QAction::setShortcut()` y configuramos su indicación de estado mediante la función ` QAction::setStatusTip()` (la indicación de estado se muestra en todas las barras de estado proporcionadas por el widget padre de nivel superior de la acción). También conectamos su señal triggered() a la ranura newFile().
El resto de las acciones se crean de manera similar. Consulta el código fuente para obtener más detalles.
alignmentGroup = new QActionGroup(this);
alignmentGroup->addAction(leftAlignAct);
alignmentGroup->addAction(rightAlignAct);
alignmentGroup->addAction(justifyAct);
alignmentGroup->addAction(centerAct);
leftAlignAct->setChecked(true);
}Una vez que hayamos creado las acciones « Left Align », « Right Align », « Justify » y « Center », también podemos crear el grupo de acciones mencionado anteriormente.
Cada acción se añade al grupo mediante la función addAction() de QActionGroup. Ten en cuenta que también se puede añadir una acción a un grupo creándola con el grupo como padre. Dado que un grupo de acciones es exclusivo por defecto, solo se marca una de las acciones del grupo en cada momento (esto se puede modificar mediante la función QActionGroup::setExclusive()).
Una vez creadas todas las acciones, utilizamos la función createMenus() para añadir las acciones a los menús e insertar los menús en la barra de menús:
void MainWindow::createMenus()
{
fileMenu = menuBar()->addMenu(tr("&File"));
fileMenu->addAction(newAct);
fileMenu->addAction(openAct);
fileMenu->addAction(saveAct);
fileMenu->addAction(printAct);
fileMenu->addSeparator();
fileMenu->addAction(exitAct);
editMenu = menuBar()->addMenu(tr("&Edit"));
editMenu->addAction(undoAct);
editMenu->addAction(redoAct);
editMenu->addSeparator();
editMenu->addAction(cutAct);
editMenu->addAction(copyAct);
editMenu->addAction(pasteAct);
editMenu->addSeparator();
helpMenu = menuBar()->addMenu(tr("&Help"));
helpMenu->addAction(aboutAct);
helpMenu->addAction(aboutQtAct);QMenuBarLa función ` addMenu()` de `'s` añade un nuevo ` QMenu ` con el título indicado a la barra de menús (ten en cuenta que la barra de menús asume la propiedad del menú). Utilizamos la función ` addAction()` de ` QWidget` para añadir cada acción al menú correspondiente.
Como alternativa, la clase QMenu proporciona varias funciones de conveniencia addAction() que crean y añaden nuevas acciones a partir de textos e iconos dados. También puedes proporcionar un miembro que se conecte automáticamente a la señal triggered() de la nueva acción, y un atajo representado por una instancia de QKeySequence.
La función QMenu::addSeparator() crea y devuelve una nueva acción separadora, es decir, una acción para la que QAction::isSeparator() devuelve «true», y añade la nueva acción a la lista de acciones del menú.
formatMenu = editMenu->addMenu(tr("&Format"));
formatMenu->addAction(boldAct);
formatMenu->addAction(italicAct);
formatMenu->addSeparator()->setText(tr("Alignment"));
formatMenu->addAction(leftAlignAct);
formatMenu->addAction(rightAlignAct);
formatMenu->addAction(justifyAct);
formatMenu->addAction(centerAct);
formatMenu->addSeparator();
formatMenu->addAction(setLineSpacingAct);
formatMenu->addAction(setParagraphSpacingAct);
}Fíjate en el menú « Format ». En primer lugar, se añade como submenú al menú « Edit » mediante la función « addMenu()» de « QMenu ». En segundo lugar, fíjate en las acciones de alineación: en la función « createActions() » añadimos las acciones « leftAlignAct », « rightAlignAct », « justifyAct » y « centerAct » a un grupo de acciones. No obstante, debemos añadir cada acción al menú por separado, mientras que el grupo de acciones hace su trabajo en segundo plano.
#ifndef QT_NO_CONTEXTMENU
void MainWindow::contextMenuEvent(QContextMenuEvent *event)
{
QMenu menu(this);
menu.addAction(cutAct);
menu.addAction(copyAct);
menu.addAction(pasteAct);
menu.exec(event->globalPos());
}
#endif // QT_NO_CONTEXTMENUPara ofrecer un menú contextual personalizado, debemos reimplementar la función contextMenuEvent() de QWidget para recibir los eventos del menú contextual del widget (ten en cuenta que la implementación por defecto simplemente ignora estos eventos).
Cada vez que recibimos uno de estos eventos, creamos un menú que contiene las acciones Cut, Copy y Paste. Los menús contextuales pueden ejecutarse de forma asíncrona mediante la función ` popup()` o de forma síncrona mediante la función ` exec()`. En este ejemplo, hemos optado por mostrar el menú utilizando su función ` exec()`. Al pasar la posición del evento como argumento, nos aseguramos de que el menú contextual aparezca en la posición esperada.
© 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.