HTMLpointHTMLpoint HTMLpoint.com


 Menús



Un menú en una aplicación no es más que un MenuBar en el que hay varios menús.
Pensemos en un programa cualquiera con las voces de menú File Edit y Help. Estas tres voces en Java son unos objetos de la clase Menú y se tienen que añadir a un objeto de la clase MenuBar que se une a la ventana. Cada menú tiene varias voces. por ejemplo, el menú File tendrá las voces: Abrir, Cerrar, Guarda y Salir. Éstos en Java son unos objetos de la clase MenuItem (o también Menú si incluyen otros submenús).



Por lo tanto, si a una aplicación le quisieramos añadir un menú tendríamos hacer las siguientes cosas siguiendo un órden cualquiera:

  • Crear los objetos MenuItem
  • Crear los objetos menú y pegarles los MenuItem
  • Crear una MenuBar y pegarles los Menús

    Además, como siempre, tenemos que escribir unos gestores para los sucesos de los menús y asociarlos a los menús.
    Veamos, en práctica, cómo se construye un menu, empezando por los MenuItem.
    Los sucesos de los MenuItem son los que tenemos que gestionar nosotros a diferencia de los sucesos de los menús que los gestiona el sistema. Mientras los segundos sirven para que aparezcan y desaparezcan las voces del menú, los primeros son los clics sobre la orden correspondiente al Item.
    Por lo tanto, para éstos tendremos que escribir unos ActionListener, como para los botones. Realmente no son otra cosa que unos botones especiales. Los constructores son tres:

    MenuItem() , que construye un MenuItem sin etiqueta.
    MenuItem(String label), que construye MenuItem con etiqueta label.
    MenuItem(String label, MenuShortcut s), que construye un MenuItem con etiqueta label y acelerador (tecla de opción rápida) definido en MenuShortcut s.

    Algunos métodos son:

    addActionListener(ActionListener l), asocia un ActionListener al MenuItem para escuchar los sucesos de tipo ActionEvent (el clic).
    void deleteShortcut(), borra la tecla de opción rápida para el menuitem.
    String getActionCommand(), da la acción asociada al MenuItem. La acción es la que pasa al actionListener del botón para identificar el botón mismo. Así varios item pueden tener el mismo gestor de sucesos que podrá distinguir el botón clicado basándose en la órden que le llega.
    String getLabel(), devuelve la etiqueta del MenuItem
    EventListener[]getListeners(Class listenerType) , devuelve todos los oyentes de sucesos asociados al MenuItem, del tipo listenerType.
    MenuShortcut getShortcut(), devuelve la definición del acelerador para el MenuItem.
    boolean isEnabled(), dice si el menú esta disponible o no. Si no lo está se visualizará en gris.
    void removeActionListener(ActionListener l), elimina el oyente asociado.
    void setActionCommand(String command), ajusta la orden asociada al MenuItem. Si no está especificado, la órden es la etiqueta del MenuItem.
    void setEnabled(boolean b), habilita y deshabilita el MenuItem.
    void setLabel(String label), ajusta la etiqueta para el MenuItem.
    void setShortcut(MenuShortcut s), define el acelerador para el menú.

    Por lo tanto, para crear los Item del menú File descrito antes tendremos que escribir:

    MenuItem abrir=new MenuItem("Abrir");
    MenuItem cerrar=new MenuItem("Cerrar");
    MenuItem guardar=new MenuItem("Guardar");
    MenuItem salir=new MenuItem("Salir");


    Por tanto creamos el objeto Menu para pegar los MenuItem.
    Dos constructores del objeto son:

    Menu(), construye un Menú sin etiqueta
    Menu(String label), construye un menú con etiqueta label.

    Entre los métodos hay:

    MenuItem add(MenuItem mi), añade un MenuItem al Menú.
    void add(String label), añade una etiqueta al Menú (tipo separador).
    void addSeparator(), añade un verdadero separador al menú, es decir, una línea.

    Añadiendo objetos a un menú de esta forma, se colocarán en el mismo órden en el que se añaden. Para especificar, en cambio, la posición en que si quieren introducir hay que usar los métodos:

    void insert(MenuItem menuitem, int index)
    void insert(String label, int index)
    void insertSeparator(int index)


    Los métodos MenuItem getItem(int index) e int getItemCount() sirven para coger un item establecido en una posición y para conocer el número de MenuItem incluidos en un menú.

    Para eliminar los Item del menú, en cambio, se utilizan los métodos:

    void remove(int index)
    void remove(MenuComponent item) e
    void removeAll()
    Por lo tanto, para crear nuestro menú File tendremos que escribir:
    Menu file= new Menu("File");
    file.add(abrir);
    file.add(guardar);
    file.add(cerrar);
    file.addSeparator();
    file.add(salir);

    Llegados e este punto, suponiendo haber creado también Edit y Help, tenemos que añadirle el MenuBar que se crea utilizando el constructor MenuBar().
    En esta barra estan los métodos remove y removeAll como para los menús, y está la add:

    Menu add(Menu m);

    Por lo tanto nuestro MenuBar se tendrá que crear de la siguiente forma:

    MenuBar barra=new MenuBar();
    barra.add(file);
    barra.add(edit);
    barra. setHelpMenu(help);


    Este último método es especial para añadir un menú de ayuda.

    Finalmente, no nos queda que asociar la barra de menú a nuestra ventana. Esto es muy simple porque nuestra ventana será una extensión de Frame y en frame está el método:

    setMenuBar(MenuBar mb);

    En nuestro caso será setMenuBar (barra);
    CUIDADO: con awt no es posible introducir menú en Dialog y en Applet (los que se ven son falsos menús, es decir, se programan dibujando unos menús o no son sólo awt), mientras con swing sí.
    A continuación mostramos el listado de una aplicación que define un menú y escucha los sucesos:

    import java.awt.*;
    import java.awt.event.*;

    public class Ventanamenú extends Frame
    {

    MenuItem abrir=new MenuItem("Abrir");
    MenuItem cerrar=new MenuItem("Cerrar");
    MenuItem salvar=new MenuItem("Guardar");
    MenuItem salir=new MenuItem("Salir");

    MenuItem cortar=new MenuItem("Cortar");
    MenuItem copiar=new MenuItem("Copiar");
    MenuItem pegar=new MenuItem("Pegar");
    MenuItem eliminar=new MenuItem("Eliminar");

    MenuItem buscar=new MenuItem("Buscar");
    MenuItem sustituir=new MenuItem("Sustituir");

    MenuItem ayuda=new MenuItem("Índice");


    Menu file= new Menu("File");
    Menu edit= new Menu("Edit");
    Menu help= new Menu("Help");

    MenuBar barra = new MenuBar();

    Label resultado=new Label("Ninguna voz de menú clicada");

    public Ventanamenú()
    {

    setupSucesos();

    file.add(abrir);
    file.add(guardar);
    file.add(cerrar);
    file.addSeparator();
    file.add("Menú Salir");
    file.addSeparator();
    file.add(salir);

    edit.add(cortar);
    edit.add(copiar);
    edit.add(pegar);
    edit.add(eliminar);
    edit.addSeparator();
    edit.add(buscar);
    edit.add(sustituir);

    help.add(ayuda);

    barra.add(file);
    barra.add(edit);
    barra.setHelpMenu(help);

    setMenuBar(barra);

    add(resultado);

    pack();
    show();
    addWindowListener(new VentanamenúWindowListener());
    }

    void setupSucesos()
    {
    abrir.addActionListener(new OyenteMenú());
    salvar.addActionListener(new OyenteMenú());
    cerrar.addActionListener(new OyenteMenú());
    salir.addActionListener(new OyenteMenú());

    cortar.addActionListener(new OyenteMenú());
    copiar.addActionListener(new OyenteMenú());
    pegar.addActionListener(new OyenteMenú());
    eliminar.addActionListener(new OyenteMenú());

    buscar.addActionListener(new OyenteMenú());
    sustituir.addActionListener(new OyenteMenú());

    ayuda.addActionListener(new OyenteMenú());


    }


    public static void main(String[] arg)
    {

    new Ventanamenú();

    }

    class OyenteMenú implements ActionListener
    {

    public void actionPerformed (ActionEvent e)
    {

    resultado.setText(" Clicado "+e.getActionCommand());
    if (e.getActionCommand().compareTo("Salir")==0) System.exit(0);

    }

    }
    class VentanamenúWindowListener implements WindowListener
    {

    public void windowActivated(WindowEvent e)
    {
    System.out.println("Escuchado un Window Activated");
    }

    public void windowClosed(WindowEvent e)
    {
    System.out.println("Escuchado un Window Closed");
    }

    public void windowClosing(WindowEvent e)
    {
    System.out.println("Escuchado un Window Closing");
    System.exit(0);
    }

    public void windowDeactivated(WindowEvent e)
    {
    System.out.println("Escuchado un Window Deactivaded");
    }

    public void windowDeiconified(WindowEvent e)
    {
    System.out.println("Escuchado un Window Deiconified");
    }

    public void windowIconified(WindowEvent e)
    {
    System.out.println("Escuchado un Window Iconified");
    }

    public void windowOpened(WindowEvent e)
    {
    System.out.println("Escuchado un Window Opened");
    }

    }

    }

    Como acabamos de ver en el ejemplo, hay otro oyente de sucesos. Escucha los sucesos de tipo WindowEvent y sirve para escuchar sucesos de la ventana.
    Para asociarlo a la ventana se utiliza el método addWindowListener(WindowListener l); en el que WindowListener es el oyente de los sucesos. Para definir un oyente de sucesos hay, por lo tanto, que implementar la interfaz WindowListener y volver a definir todos los métodos:

    class MÍOYENTE implements WindowListener

    Los métodos para definir son:

    public void windowActivated(WindowEvent e)
    public void windowClosed(WindowEvent e)
    public void windowClosing(WindowEvent e)
    public void windowDeactivated(WindowEvent e)
    public void windowDeiconified(WindowEvent e)
    public void windowIconified(WindowEvent e)
    public void windowOpened(WindowEvent e)


    Hay que volver a definirlos todos.
    Si ponemos en marcha el ejemplo vemos, gracias a las System.out.println colocadas en los métodos redefinidos, a qué tipo de suceso de la ventana están asociados los distintos métodos, como, por ejemplo, windowClosed se invoca cuando se pulsa la X de la ventana.

    Como ejercicio intentad escribir unos WindowListener para escuchar el suceso cerrar Ventana para todos los Frame definidos en los ejemplos de este capítulo (los dejé a posta sin definición).

    Los menús analizados no son los únicos que se pueden implementar en Java. Otro tipo de menú es el de tipo Popup, es decir, el menú que se asocia a un componente o a una posición. Un ejemplo de menú popup es el que sale en el desktop del sistema operativo Windows cuando se aprieta el botón derecho del ratón (véase Dibujo).



    Para crear un menú popup hay que crear un objeto que pertenezca a la clase PopupMenu, utilizando uno de los constructores: PopupMenu(), PopupMenu(String label), que crean, respectivamente, un menú sin o con etiqueta.

    PopupMenu es una extensión de Menú, por lo tanto hereda los métodos incluso los que sirven para añadir y eliminar unos MenuItem. En cambio, entre sus métodos hay uno para visualizar el menú en una posición establecida de la pantalla con respecto a un determinado componente: show(Component origin, int x, int y)


  •   Volver al inicio de la página