1. Veamos como añadir una barra de menús a nuestras aplicaciones. En primer lugar, crea un proyecto con el NetBeans.
2. Añade a tu ventana un objeto JMenuBar
3. En la parte superior de tu ventana aparecerá esto:
4. En el inspector (parte inferior izquierda) observarás como aparece un objeto JMenuBar, y, dentro de él, un objeto del tipo JMenu. Los objetos JMenu representan las opciones principales contenidas dentro de la barra de menús.
5. Aprovecha el Inspector para cambiar el nombre al objeto JMenuBar. Llámalo barraMenus.
6. Cambia también el nombre al objeto JMenu. Asígnale el nombre menuArchivo. El Inspector tendrá el siguiente aspecto:
8.Ahora el aspecto de la barra de menús será el siguiente:
9. Puedes añadir más opciones principales a la barra de menús haciendo clic con el derecho sobre el objeto de la barra de menús y activando la opción “Añadir JMenu”.
10. Añada dos opciones más a la barra de menús. El inspector debe tener ahora el siguiente aspecto:
12. Cambia los nombres de las dos nuevas opciones. Sus nombres serán: menuEdicion y menuInsertar.
13. Cambia los textos de ambas opciones. Sus textos serán: “Edición” e “Insertar”.
14. Ya tenemos creada la barra de menús (JMenuBar) con sus opciones principales (JMenu). Ahora se tendrán que definir las opciones contenidas en cada opción principal. Por ejemplo, crearemos las opciones contenidas en el menú Archivo.
15. Haz clic con el botón derecho sobre el objeto menuArchivo y activa la opción “Añadir – JMenuItem”.
Los JMenuItem son objetos que representan las opciones contenidas en los menús desplegables de la barra de menús.
16. Añade un JMenuItem más al menuArchivo y luego cambia el nombre a ambos. Sus nombres serán menuItemAbrir y menuItemGuardar. El aspecto del Inspector será el siguiente:
18. Ya podemos ejecutar el programa para ver que es lo que se ha conseguido. Use el menú
Observa como la opción Archivo se despliega mostrando dos submenús: Abrir y Guardar.
19. Seguiremos añadiendo elementos al menú. Ahora haga clic con el derecho sobre el elemento menuArchivo y añada un JSeparator.
Los JSeparator son objetos que definen una separación entre las opciones de un menú. Cámbiele el nombre y llámelo “separador1”:
20. Añada un nuevo JMenuItem al menú Archivo y ponle el nombre menuSalir. El texto de esta opción será “Salir” (use su propiedad text) El aspecto del Inspector será el siguiente:
21.Ejecuta el programa y observa el contenido de la opción Archivo del menú:
Observa el efecto que produce el separador.
22. Un JMenu representa las opciones principales de la barra de menús. A su vez, un JMenu contiene JMenuItem, que son las opciones contenidas en cada opción principal, y que se ven cuando se despliega el menú.
Sin embargo, un JMenu puede contener a otros JMenu, que a su vez contendrán varios JMenuItem. Usando el botón derecho del ratón y la opción “Añadir”, añade un JMenu dentro de menuEdicion:
23. Llama al nuevo JMenu menuColores y asignale el texto “Colores”.
La opción Edición (JMenu) contiene una opción Colores (JMenu) que a su vez contiene las opciones Rojo, Verde y Azul (JMenuItems)
26. De nada sirve crear un menú si luego este no reacciona a las pulsaciones del ratón. Cada objeto del menú tiene un evento ActionPerformed que permite programar lo que debe suceder cuando se active dicha opción del menú.
27. Marque en el inspector el objeto menuItemRojo y acceda a su evento ActionPerformed. Dentro de él programe este sencillo código:
this.getContentPane().setBackground(Color.RED);
Este código cambia el color de fondo de la ventana a rojo.
28. Compruebe el funcionamiento de la opción “Rojo” del menú ejecutando el programa.
29. Programa tu mismo las opciones “Verde” y “Azul”.
CONCLUSIÓN
Las barras de menús son un conjunto de objetos de distinto tipo que se contienen unos a los otros:
La barra en sí está representada por un objeto del tipo JMenuBar.
La barra contiene opciones principales, representadas por objetos JMenu.
Las opciones principales contienen opciones que aparecen al desplegarse el menú. Esta opciones son objetos del tipo JMenuItem.
Un JMenu también puede contener otros JMenu, que a su vez contendrán JMenuItems.
También puede añadir separadores (JSeparator) que permiten visualizar mejor las opciones dentro de un menú.
MENÚS EMERGENTES
El evento mouseClicked
El evento mouseClicked es capaz de capturar un clic del ratón sobre un determinado elemento de la ventana.
Este evento recibe como parámetro un objeto del tipo MouseEvent, y gracias a él se puede conseguir información como la siguiente:
- Qué botón del ratón fue pulsado.
- Cuantas veces (clic, doble clic, etc)
- En qué coordenadas fue pulsado el botón.
- Etc.
Se puede usar esta información para saber por ejemplo si se pulsó el botón derecho del ratón, y sacar en este caso un menú contextual en pantalla.
En este ejercicio guiado se estudiarán las posibilidades del evento mouseClicked y se aplicarán a la creación y visualización de menús contextuales (o emergentes)
1. Crea un nuevo proyecto.
2. No hace falta que añada nada a la ventana.
3. Programaremos la pulsación del ratón sobre el formulario, así que haga clic sobre el formulario y active el evento mouseClicked.
4. Observe el código del evento:
private void formMouseClicked(java.awt.event.MouseEvent evt) {
// TODO add your handling code here:
}
Este evento recibe como parámetro un objeto llamado evt del tipo MouseEvent (en rojo en el código) que nos permite saber en qué condiciones se hizo clic.
5. Dentro del evento programe lo siguiente:
if (evt.getButton()==1) {
JOptionPane.showMessageDialog(null,"Pulso el izquierdo");
} else if (evt.getButton()==2) {
JOptionPane.showMessageDialog(null,"Pulso el central");
} else if (evt.getButton()==3) {
JOptionPane.showMessageDialog(null,"Pulso el derecho");
}
6. Ejecuta el programa y haz clic sobre el formulario con el botón derecho, con el izquierdo y con el central. Observa el resultado.
7. Ahora quizás puedas comprender el código anterior. En él, se usa el método getButton del objeto evt para saber qué botón se pulsó. El método getButton devuelve un entero que puede ser 1, 2 o 3 según el botón pulsado.
8. Se puede aprovechar el método getButton para controlar la pulsación del botón derecho del ratón y así sacar un menú contextual. Pero antes, es necesario crear el menú.
9. Agrega a tu formulario un objeto del tipo JPopupMenu. Estos objetos definen menús emergentes.
10. Los objetos JPopupMenu no se muestran en el formulario, pero puedes verlo en el Inspector dentro de la rama de Otros
Componentes:
11. Aprovecharemos el inspector para cambiar el nombre al menú. Llámalo menuEmergente.
12. Los menús emergentes se crean igual que las opciones de menús normales, añadiendo con el botón derecho del ratón objetos JMenuItem.
13. Añada al menú emergente tres JMenuItem, y asígneles los siguientes nombres a cada uno: menuRojo, menuVerde, menuAzul. El inspector debería tener el siguiente aspecto:
14. Tienes que cambiar la propiedad text de cada opción del menú. Recuerda que esta propiedad define lo que aparece en el menú. Asignarás los siguientes textos: “Rojo”, “Verde” y “Azul”.
15. El menú emergente ya está construido. Ahora tenemos que hacer que aparezca cuando el usuario pulse el botón derecho del ratón sobre el formulario. Para ello, entraremos de nuevo en el evento mouseClicked del formulario y cambiaremos su código por el siguiente:
menuEmergente.show(this,evt.getX(),evt.getY());
16. Este código significa lo siguiente:
- El método show le da la orden al menuEmergente para que se muestre.
- El método show recibe tres elementos: por un lado la ventana donde actúa (this)
- Por otro lado la posición x donde debe mostrarse el menú. Esta posición es aquella donde se pulsó el ratón, y se puede conseguir gracias al método getX del objeto evt.
- Por último se necesita la posición y. Esta posición se puede conseguir gracias al método getY del objeto evt.
Es decir, decidimos mostrar el menú emergente justo en las coordenadas donde se hizo clic.
17. Ejecuta el programa y observa el resultado.
Al hacer clic con el derecho se mostrará el menú contextual.
18. Para hacer que al pulsarse una opción suceda algo, solo hay que activar el método actionPerformed del JMenuItem correspondiente. Por ejemplo, active el actionPerformed del menuRojo y dentro programe lo siguiente:
this.getContentPane().setBackground(Color.RED);
19. Ejecuta el programa y comprueba lo que sucede al pulsar la opción Rojo del menú contextual.
CONCLUSIÓN
Los menús contextuales son objetos del tipo JPopupMenu. Estos objetos contienen JMenuItem al igual que las opciones de menú normales.
Cuando se asigna un JPopupMenu a un formulario, no aparece sobre la ventana, pero sí en el inspector.
Para hacer que aparezca el menú emergente, es necesario programar el evento mouseClicked del objeto
sobre el que quiera que aparezca el meú.
Tendrá que usar el método show del menú emergente para mostrar dicho menú.
Puedes descargar por dropbox Aquí
