QMenu Class
La clase QMenu proporciona un control de menú para su uso en barras de menú, menús contextuales y otros menús emergentes. Más...
| Encabezado: | #include <QMenu> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Widgets) target_link_libraries(mytarget PRIVATE Qt6::Widgets) |
| qmake: | QT += widgets |
| Heredado de: | QWidget |
Propiedades
|
|
Funciones públicas
| QMenu(QWidget *parent = nullptr) | |
| QMenu(const QString &title, QWidget *parent = nullptr) | |
| virtual | ~QMenu() |
| QAction * | actionAt(const QPoint &pt) const |
| QRect | actionGeometry(QAction *act) const |
| QAction * | activeAction() const |
| QAction * | addMenu(QMenu *menu) |
| QMenu * | addMenu(const QString &title) |
| QMenu * | addMenu(const QIcon &icon, const QString &title) |
| QAction * | addSection(const QString &text) |
| QAction * | addSection(const QIcon &icon, const QString &text) |
| QAction * | addSeparator() |
| void | clear() |
| QAction * | defaultAction() const |
| QAction * | exec() |
| QAction * | exec(const QPoint &p, QAction *action = nullptr) |
| void | hideTearOffMenu() |
| QIcon | icon() const |
| QAction * | insertMenu(QAction *before, QMenu *menu) |
| QAction * | insertSection(QAction *before, const QString &text) |
| QAction * | insertSection(QAction *before, const QIcon &icon, const QString &text) |
| QAction * | insertSeparator(QAction *before) |
| bool | isEmpty() const |
| bool | isTearOffEnabled() const |
| bool | isTearOffMenuVisible() const |
| QAction * | menuAction() const |
| void | popup(const QPoint &p, QAction *atAction = nullptr) |
| bool | separatorsCollapsible() const |
| void | setActiveAction(QAction *act) |
| void | setAsDockMenu() |
| void | setDefaultAction(QAction *act) |
| void | setIcon(const QIcon &icon) |
| void | setSeparatorsCollapsible(bool collapse) |
| void | setTearOffEnabled(bool) |
| void | setTitle(const QString &title) |
| void | setToolTipsVisible(bool visible) |
| void | showTearOffMenu(const QPoint &pos) |
| void | showTearOffMenu() |
| QString | title() const |
| NSMenu * | toNSMenu() |
| bool | toolTipsVisible() const |
Funciones públicas reimplementadas
| virtual QSize | sizeHint() const override |
Señales
| void | aboutToHide() |
| void | aboutToShow() |
| void | hovered(QAction *action) |
| void | triggered(QAction *action) |
Miembros públicos estáticos
| QAction * | exec(const QList<QAction *> &actions, const QPoint &pos, QAction *at = nullptr, QWidget *parent = nullptr) |
| QMenu * | menuInAction(const QAction *action) |
Funciones protegidas
| int | columnCount() const |
| virtual void | initStyleOption(QStyleOptionMenuItem *option, const QAction *action) const |
Funciones protegidas reimplementadas
| virtual void | actionEvent(QActionEvent *e) override |
| virtual void | changeEvent(QEvent *e) override |
| virtual void | enterEvent(QEnterEvent *) override |
| virtual bool | event(QEvent *e) override |
| virtual bool | focusNextPrevChild(bool next) override |
| virtual void | hideEvent(QHideEvent *) override |
| virtual void | keyPressEvent(QKeyEvent *e) override |
| virtual void | leaveEvent(QEvent *) override |
| virtual void | mouseMoveEvent(QMouseEvent *e) override |
| virtual void | mousePressEvent(QMouseEvent *e) override |
| virtual void | mouseReleaseEvent(QMouseEvent *e) override |
| virtual void | paintEvent(QPaintEvent *e) override |
| virtual void | timerEvent(QTimerEvent *e) override |
| virtual void | wheelEvent(QWheelEvent *e) override |
Descripción detallada

Un widget de menú es un menú de selección. Puede ser un menú desplegable en una barra de menús o un menú contextual independiente. Los menús desplegables se muestran en la barra de menús cuando el usuario hace clic en el elemento correspondiente o pulsa la tecla de acceso rápido especificada. Utiliza QMenuBar::addMenu() para insertar un menú en una barra de menús. Los menús contextuales suelen activarse mediante una tecla especial del teclado o haciendo clic con el botón derecho del ratón. Pueden ejecutarse de forma asíncrona con popup() o de forma síncrona con exec(). Los menús también pueden activarse al pulsar un botón; son iguales que los menús contextuales, salvo por la forma en que se activan.
Acciones
Un menú consta de una lista de elementos de acción. Las acciones se añaden mediante las funciones `addAction()`, ` addActions()` y ` insertAction()`. Una acción se representa verticalmente y se muestra mediante ` QStyle`. Además, las acciones pueden tener una etiqueta de texto, un icono opcional dibujado en el extremo izquierdo y una secuencia de teclas de acceso rápido, como «Ctrl+X».
Las acciones existentes en un menú se pueden consultar mediante actions().
Hay cuatro tipos de elementos de acción: separadores, acciones que muestran un submenú, widgets y acciones que ejecutan una acción. Los separadores se insertan con ` addSeparator()`; los submenús, con ` addMenu()`; y todos los demás elementos se consideran elementos de acción.
Al insertar elementos de acción, normalmente se especifica un receptor y una ranura. El receptor recibirá una notificación cada vez que se ejecute la acción triggered(). Además, QMenu proporciona dos señales, triggered() y hovered(), que indican al QAction qué acción se ha activado desde el menú.
Para borrar un menú, se utiliza clear(), y para eliminar elementos de acción individuales, removeAction().
Un QMenu también puede proporcionar un menú separable. Un menú separable es una ventana de nivel superior que contiene una copia del menú. Esto permite al usuario «separar» los menús que utiliza con frecuencia y colocarlos en un lugar conveniente de la pantalla. Si desea esta funcionalidad para un menú concreto, inserte un controlador de separación con ` setTearOffEnabled()`. Al utilizar menús separables, tenga en cuenta que este concepto no se suele emplear en Microsoft Windows, por lo que es posible que algunos usuarios no estén familiarizados con él. Considere la posibilidad de utilizar una ` QToolBar ` en su lugar.
Se pueden insertar widgets en los menús mediante la clase ` QWidgetAction `. Las instancias de esta clase se utilizan para contener widgets y se insertan en los menús mediante la sobrecarga `addAction()` que toma un ` QAction`. Si ` QWidgetAction ` emite la señal ` triggered()`, el menú se cerrará.
Advertencia: Para que QMenu sea visible en pantalla, se debe utilizar exec() o popup() en lugar de show() o setVisible(). Para ocultar o desactivar el menú en la barra de menús, o en otro menú al que se haya añadido como submenú, utilice en su lugar las propiedades correspondientes de menuAction().
QMenu en macOS con Qt compilado con Cocoa
QMenu solo se puede insertar una vez en un menú o barra de menús. Las inserciones posteriores no tendrán ningún efecto o darán lugar a un elemento de menú desactivado.
Consulta el ejemplo «Menús» para ver cómo utilizar QMenuBar y QMenu en tu aplicación.
Funciones heredadas importantes: addAction(), removeAction(), clear(), addSeparator() y addMenu().
Véase también el ejemplo« QMenuBar » y «Menus».
Documentación de propiedades
icon : QIcon
Esta propiedad contiene el icono del menú
Esto equivale a la propiedad « QAction::icon » del objeto « menuAction » ().
Por defecto, si no se ha establecido ningún icono de forma explícita, esta propiedad contiene un icono nulo.
Funciones de acceso:
| QIcon | icon() const |
| void | setIcon(const QIcon &icon) |
separatorsCollapsible : bool
Esta propiedad determina si los separadores consecutivos deben ocultarse
Esta propiedad especifica si los separadores consecutivos del menú deben ocultarse visualmente para que aparezcan como uno solo. Los separadores situados al principio o al final del menú también se ocultan.
Por defecto, esta propiedad está est true.
Funciones de acceso:
| bool | separatorsCollapsible() const |
| void | setSeparatorsCollapsible(bool collapse) |
tearOffEnabled : bool
Esta propiedad indica si el menú permite ser desprendido
Si el valor es «true», el menú contiene un elemento especial de separación (que suele aparecer como una línea discontinua en la parte superior del menú) que crea una copia del menú cuando se activa.
Esta copia «separada» se muestra en una ventana independiente. Contiene los mismos elementos de menú que el menú original, a excepción del controlador de separación.
Por defecto, esta propiedad tiene el valor « false ».
Funciones de acceso:
| bool | isTearOffEnabled() const |
| void | setTearOffEnabled(bool) |
title : QString
Esta propiedad define el título del menú
Esto equivale a la propiedad « QAction::text » del método « menuAction()».
Por defecto, esta propiedad contiene una cadena vacía.
Funciones de acceso:
| QString | title() const |
| void | setTitle(const QString &title) |
toolTipsVisible : bool
Esta propiedad determina si deben mostrarse las descripciones emergentes de las acciones del menú
Esta propiedad especifica si las entradas del menú de acciones muestran su información sobre herramientas.
Por defecto, esta propiedad está p false.
Funciones de Access:
| bool | toolTipsVisible() const |
| void | setToolTipsVisible(bool visible) |
Documentación de funciones de miembro
[explicit] QMenu::QMenu(QWidget *parent = nullptr)
Crea un menú con el elemento padre « parent ».
Aunque un menú emergente es siempre un widget de nivel superior, si se le pasa un elemento padre, el menú emergente se eliminará cuando se destruya dicho elemento padre (al igual que con cualquier otro QObject).
[explicit] QMenu::QMenu(const QString &title, QWidget *parent = nullptr)
Crea un menú con un « title » y un « parent ».
Aunque un menú emergente es siempre un widget de nivel superior, si se le pasa un padre, el menú emergente se eliminará cuando se destruya dicho padre (al igual que ocurre con cualquier otro QObject).
Véase también « title ».
[virtual noexcept] QMenu::~QMenu()
Elimina el menú.
[signal] void QMenu::aboutToHide()
Esta señal se emite justo antes de que el menú desaparezca de la vista del usuario.
Véase también aboutToShow() y hide().
[signal] void QMenu::aboutToShow()
Esta señal se emite justo antes de que se muestre el menú al usuario.
Véase también aboutToHide() y show().
QAction *QMenu::actionAt(const QPoint &pt) const
Devuelve el elemento de pt; devuelve nullptr si no hay ningún elemento en esa dirección.
[override virtual protected] void QMenu::actionEvent(QActionEvent *e)
Reimplementa: QWidget::actionEvent(QActionEvent *event).
QRect QMenu::actionGeometry(QAction *act) const
Devuelve la geometría de la acción act.
QAction *QMenu::activeAction() const
Devuelve la acción seleccionada actualmente o ` nullptr ` si no hay ninguna acción seleccionada.
Véase también setActiveAction().
QAction *QMenu::addMenu(QMenu *menu)
Esta función de conveniencia añade « menu » como submenú a este menú. Devuelve el resultado de la función menuAction() de menu. Este menú no asume la propiedad de menu.
Véase también QWidget::addAction() y QMenu::menuAction().
QMenu *QMenu::addMenu(const QString &title)
Añade al menú un nuevo elemento « QMenu » con el texto « title ». El menú asume la propiedad de dicho elemento. Devuelve el nuevo menú.
Véase también QWidget::addAction() y QMenu::menuAction().
QMenu *QMenu::addMenu(const QIcon &icon, const QString &title)
Añade al menú un nuevo elemento « QMenu » con las direcciones icon y title. El menú asume la propiedad de dicho elemento. Devuelve el nuevo menú.
Véase también QWidget::addAction() y QMenu::menuAction().
QAction *QMenu::addSection(const QString &text)
Esta función de conveniencia crea una nueva acción de sección, es decir, una acción cuyo método ` QAction::isSeparator()` devuelve «true», pero que también incluye la indicación ` text `, y añade la nueva acción a la lista de acciones de este menú. Devuelve la acción recién creada.
La visualización de la sugerencia depende del estilo y de la plataforma. Los estilos de los widgets pueden utilizar la información de texto en la visualización de las secciones, o pueden optar por ignorarla y mostrar las secciones como simples separadores.
QMenu Asume la propiedad del objeto ` QAction` devuelto.
Véase también ` QWidget::addAction()`.
QAction *QMenu::addSection(const QIcon &icon, const QString &text)
Esta función de conveniencia crea una nueva acción de sección, es decir, una acción cuyo método ` QAction::isSeparator()` devuelve `true`, pero que también cuenta con las sugerencias ` text ` y ` icon `, y añade la nueva acción a la lista de acciones de este menú. Devuelve la acción recién creada.
La visualización de las sugerencias depende del estilo y de la plataforma. Los estilos de los widgets pueden utilizar la información de texto e icono en la visualización de las secciones, o pueden optar por ignorarlas y mostrar las secciones como simples separadores.
QMenu Asume la propiedad del objeto ` QAction` devuelto.
Véase también QWidget::addAction().
QAction *QMenu::addSeparator()
Esta función de conveniencia crea una nueva acción separadora, es decir, una acción en la que QAction::isSeparator() devuelve «true», y añade la nueva acción a la lista de acciones de este menú. Devuelve la acción recién creada.
QMenu Asume la propiedad del objeto ` QAction` devuelto.
Véase también ` QWidget::addAction()`.
[override virtual protected] void QMenu::changeEvent(QEvent *e)
Reimplementa: ` QWidget::changeEvent(QEvent *event)`.
void QMenu::clear()
Elimina todas las acciones del menú. Se eliminan las acciones que pertenecen al menú y que no aparecen en ningún otro widget.
Véase también removeAction().
[protected] int QMenu::columnCount() const
Si un menú no cabe en la pantalla, se reorganiza para que quepa. El significado de «reorganización» depende del estilo (por ejemplo, en Windows se utilizarán varias columnas).
Esta función devuelve el número de columnas necesarias.
QAction *QMenu::defaultAction() const
Devuelve la acción predeterminada actual.
Véase también setDefaultAction().
[override virtual protected] void QMenu::enterEvent(QEnterEvent *)
Reimplementa: QWidget::enterEvent(QEnterEvent *event).
[override virtual protected] bool QMenu::event(QEvent *e)
Reimplementa: ` QWidget::event(QEvent *event)`.
QAction *QMenu::exec()
Ejecuta este menú de forma sincrónica.
Esto equivale a ` exec(pos())`.
Devuelve el ` QAction ` activado, ya sea en el menú emergente o en uno de sus submenús, o bien ` nullptr ` si no se ha activado ningún elemento (normalmente porque el usuario ha pulsado Esc).
En la mayoría de los casos, querrás especificar la posición tú mismo, por ejemplo, la posición actual del ratón:
exec(QCursor::pos());o alineada con un widget:
exec(somewidget.mapToGlobal(QPoint(0,0)));o en respuesta a un evento « QMouseEvent » *e:
exec(e->globalPosition().toPoint());QAction *QMenu::exec(const QPoint &p, QAction *action = nullptr)
Ejecuta este menú de forma sincrónica.
Muestra el menú de forma que la acción action se sitúe en la posición global especificada p. Para convertir las coordenadas locales de un widget en coordenadas globales, utiliza QWidget::mapToGlobal().
Esto devuelve el elemento activado QAction, ya sea en el menú emergente o en uno de sus submenús, o bien nullptr si no se ha activado ningún elemento (normalmente porque el usuario ha pulsado Esc).
Ten en cuenta que todas las señales se emiten como de costumbre. Si conectas un ` QAction ` a un `slot` y llamas a `exec()` del menú, obtienes el resultado tanto a través de la conexión señal-slot como en el valor de retorno de `exec()`.
Lo habitual es colocar el menú en la posición actual del ratón:
exec(QCursor::pos());o alineado con un widget:
exec(somewidget.mapToGlobal(QPoint(0, 0)));o en respuesta a un evento *e de QMouseEvent:
exec(e->globalPosition().toPoint());Al colocar un menú con `exec()` o ` popup()`, ten en cuenta que no puedes fiarte del valor actual de ` size()` del menú. Por motivos de rendimiento, el menú adapta su tamaño solo cuando es necesario. Por lo tanto, en muchos casos, el tamaño antes y después de mostrarlo es diferente. En su lugar, utiliza sizeHint(), que calcula el tamaño adecuado en función del contenido actual del menú.
Se trata de una función sobrecargada.
Véanse también popup() y QWidget::mapToGlobal().
[static] QAction *QMenu::exec(const QList<QAction *> &actions, const QPoint &pos, QAction *at = nullptr, QWidget *parent = nullptr)
Ejecuta un menú de forma sincrónica.
Las acciones del menú se especifican mediante la lista de actions. El menú aparecerá de forma que la acción especificada, at, se muestre en la posición global pos. Si no se especifica at, el menú aparecerá en la posición pos. parent es el widget padre del menú; especificar el padre proporcionará contexto cuando pos por sí solo no sea suficiente para decidir dónde debe situarse el menú (por ejemplo, con varios escritorios o cuando el padre está incrustado en QGraphicsView).
La función devuelve el elemento activado QAction, ya sea en el menú emergente o en uno de sus submenús, o bien nullptr si no se ha activado ningún elemento (normalmente porque el usuario ha pulsado Esc).
Esto equivale a:
QMenu menu;
QAction *at = actions[0]; // Assumes actions is not empty
for (QAction *a : std::as_const(actions))
menu.addAction(a);
menu.exec(pos, at);Esta es una función sobrecargada.
Véanse también popup() y QWidget::mapToGlobal().
[override virtual protected] bool QMenu::focusNextPrevChild(bool next)
Reimplementa: ` QWidget::focusNextPrevChild` (bool next).
[override virtual protected] void QMenu::hideEvent(QHideEvent *)
Reimplementa: QWidget::hideEvent(QHideEvent *event).
void QMenu::hideTearOffMenu()
Esta función ocultará de forma forzada el menú desprendido, haciendo que desaparezca del escritorio del usuario.
Véase también showTearOffMenu(), isTearOffMenuVisible() y isTearOffEnabled().
[signal] void QMenu::hovered(QAction *action)
Esta señal se emite cuando se resalta una acción del menú; ` action ` es la acción que ha provocado la emisión de la señal.
A menudo se utiliza para actualizar la información de estado.
Véase también triggered() y QAction::hovered().
[virtual protected] void QMenu::initStyleOption(QStyleOptionMenuItem *option, const QAction *action) const
Inicializa ` option ` con los valores de este menú y la información de action. Este método resulta útil para las subclases cuando necesitan un ` QStyleOptionMenuItem`, pero no desean introducir toda la información por sí mismas.
Véase también QStyleOption::initFrom() y QMenuBar::initStyleOption().
QAction *QMenu::insertMenu(QAction *before, QMenu *menu)
Esta función de conveniencia inserta menu antes de la acción before y devuelve los menús menuAction().
Véanse también QWidget::insertAction() y addMenu().
QAction *QMenu::insertSection(QAction *before, const QString &text)
Esta función de conveniencia crea una nueva acción de título, es decir, una acción cuyo método ` QAction::isSeparator()` devuelve «true», pero que también incluye la sugerenci text. La función inserta la acción recién creada en la lista de acciones de este menú, antes de la acción ` before `, y la devuelve.
La visualización de la sugerencia depende del estilo y de la plataforma. Los estilos de los widgets pueden utilizar la información del texto en la visualización de las secciones, o pueden optar por ignorarla y mostrar las secciones como simples separadores.
QMenu Asume la propiedad del objeto ` QAction` devuelto.
Véase también « QWidget::insertAction()» y « addSection()».
QAction *QMenu::insertSection(QAction *before, const QIcon &icon, const QString &text)
Esta función de conveniencia crea una nueva acción de título, es decir, una acción cuyo método ` QAction::isSeparator()` devuelve «true», pero que también incluye las sugerencias ` text ` y ` icon `. La función inserta la acción recién creada en la lista de acciones de este menú, justo antes de la acción ` before `, y la devuelve.
La representación de las sugerencias depende del estilo y de la plataforma. Los estilos de los widgets pueden utilizar la información de texto e iconos en la representación de las secciones, o pueden optar por ignorarlas y representar las secciones como simples separadores.
QMenu Asume la propiedad del objeto ` QAction` devuelto.
Véase también QWidget::insertAction() y addSection().
QAction *QMenu::insertSeparator(QAction *before)
Esta función de conveniencia crea una nueva acción separadora, es decir, una acción cuyo método ` QAction::isSeparator()` devuelve «true». La función inserta la acción recién creada en la lista de acciones de este menú, antes de la acción ` before `, y la devuelve.
QMenu Asume la propiedad del objeto QAction devuelto.
Véanse también QWidget::insertAction() y addSeparator().
bool QMenu::isEmpty() const
Devuelve « true » si no hay acciones visibles insertadas en el menú; en caso contrario, devuelve «false».
Véase también QWidget::actions().
bool QMenu::isTearOffMenuVisible() const
Cuando se abre un menú, se muestra un segundo menú para visualizar su contenido en una nueva ventana. Si el menú se encuentra en este modo y está visible, devuelve « true »; en caso contrario, devuelve «false».
Véase también showTearOffMenu(), hideTearOffMenu() y isTearOffEnabled().
[override virtual protected] void QMenu::keyPressEvent(QKeyEvent *e)
Reimplementa: ` QWidget::keyPressEvent(QKeyEvent *event)`.
[override virtual protected] void QMenu::leaveEvent(QEvent *)
Reimplementa: QWidget::leaveEvent(QEvent *event).
QAction *QMenu::menuAction() const
Devuelve la acción asociada a este menú.
[static] QMenu *QMenu::menuInAction(const QAction *action)
Devuelve el menú que contiene action, o bien nullptr si action no contiene ningún menú.
En las aplicaciones de widgets, las acciones que contienen menús pueden utilizarse para crear elementos de menú con submenús, o insertarse en barras de herramientas para crear botones con menús emergentes.
[override virtual protected] void QMenu::mouseMoveEvent(QMouseEvent *e)
Reimplementa: ` QWidget::mouseMoveEvent(QMouseEvent *event)`.
[override virtual protected] void QMenu::mousePressEvent(QMouseEvent *e)
Reimplementa: ` QWidget::mousePressEvent(QMouseEvent *event)`.
[override virtual protected] void QMenu::mouseReleaseEvent(QMouseEvent *e)
Reimplementa: ` QWidget::mouseReleaseEvent(QMouseEvent *event)`.
[override virtual protected] void QMenu::paintEvent(QPaintEvent *e)
Reimplementa: QWidget::paintEvent(QPaintEvent *event).
void QMenu::popup(const QPoint &p, QAction *atAction = nullptr)
Muestra el menú de forma que la acción « atAction » se sitúe en la posición global especificada « p ». Para convertir las coordenadas locales de un widget en coordenadas globales, utiliza « QWidget::mapToGlobal()».
Al posicionar un menú con exec() o popup(), ten en cuenta que no puedes fiarte de la posición actual del menú size(). Por motivos de rendimiento, el menú adapta su tamaño solo cuando es necesario, por lo que, en muchos casos, el tamaño antes y después de mostrarlo es diferente. En su lugar, utiliza sizeHint(), que calcula el tamaño adecuado en función del contenido actual del menú.
Véanse también « QWidget::mapToGlobal()» y « exec()».
void QMenu::setActiveAction(QAction *act)
Establece la acción actualmente seleccionada como « act ».
Véase también activeAction().
void QMenu::setAsDockMenu()
Configura este menú para que sea el menú del Dock al que se accede haciendo clic con la tecla Opción pulsada sobre el icono de la aplicación en el Dock. Disponible únicamente en macOS.
void QMenu::setDefaultAction(QAction *act)
Esto establece la acción predeterminada en « act ». La acción predeterminada puede ir acompañada de una indicación visual, dependiendo de la configuración actual de « QStyle ». Una acción predeterminada suele indicar qué ocurrirá por defecto cuando se suelte un elemento.
Véase también defaultAction().
void QMenu::showTearOffMenu(const QPoint &pos)
Esta función mostrará de forma forzada el menú separado, haciendo que aparezca en el escritorio del usuario en la posición global especificada pos.
Véase también hideTearOffMenu(), isTearOffMenuVisible() y isTearOffEnabled().
void QMenu::showTearOffMenu()
Esta función mostrará de forma forzada el menú separado, haciendo que aparezca en el escritorio del usuario debajo del cursor del ratón.
Se trata de una función sobrecargada.
Véanse también « hideTearOffMenu()», « isTearOffMenuVisible()» y « isTearOffEnabled()».
[override virtual] QSize QMenu::sizeHint() const
Reimplementa una función de acceso para la propiedad: QWidget::sizeHint.
[override virtual protected] void QMenu::timerEvent(QTimerEvent *e)
Reimplementa: QObject::timerEvent(QTimerEvent *event).
NSMenu *QMenu::toNSMenu()
Devuelve el NSMenu nativo de este menú. Disponible únicamente en macOS.
Nota: Qt establece el delegado en el menú nativo. Si necesitas establecer tu propio delegado, asegúrate de guardar el original y reenviar cualquier llamada que se le realice.
[signal] void QMenu::triggered(QAction *action)
Esta señal se emite cuando se activa una acción de este menú.
action es la acción que ha provocado la emisión de la señal.
Normalmente, se conecta la señal « triggered()» de cada acción del menú a su propia ranura personalizada, pero a veces querrás conectar varias acciones a una única ranura, por ejemplo, cuando tengas un grupo de acciones estrechamente relacionadas, como «justificar a la izquierda», «centrar» y «justificar a la derecha».
Nota: Esta señal se emite para el menú principal de un árbol jerárquico. Por lo tanto, solo es necesario conectar el menú principal a una ranura; no es necesario conectar los submenús.
Véase también hovered() y QAction::triggered().
[override virtual protected] void QMenu::wheelEvent(QWheelEvent *e)
Reimplementa: ` QWidget::wheelEvent` (`QWheelEvent *event)`.
© 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.