HTMLpointHTMLpoint HTMLpoint.com


 La gestión de los sucesos en Java2



Hemos visto casi todos los componentes GUI de awt. Para construir una interfaz basta con combinarlos y escuchar los sucesos.
Por cada GUI analizada, hemos visto cómo gestionar unos sucesos. Ahora vamos a ver qué sucesos se pueden escuchar.
En primer lugar hemos escuchado unos sucesos de tipo ActionEvent, es decir, sucesos que actúan sobre las GUI gracias al usuario como, por ejemplo, pulsar un botón.
Para esto, os recuerdo que hemos implementado la interfaz ActionListener, y hemos vuelto a definir el único suceso actionPerformed (ActionEvent e), que se invoca cuando se pone en marcha una acción sobre el componente GUI (o sobre los componentes) a los que está asociado.
Para asociar al GUI el oyente de los sucesos que hemos definido, hemos utilizado el método addActionListener (ActionListener oyente) del GUI.
Para usarlos hay que incluir en el programa:

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;


o

impore java.awt.event.*;

Oyentes de sucesos de tipo ActionListener se pueden asociar a los objetos GUI de awt:

Button
List (cuando seleccionamos o no seleccionamos un elemento)
MenuItem
TextField


Hemos visto también cómo implementar un ItemListener, para escuchar sucesos de la GUI que tienen un estado de on/off, cuando modifican su propiio estado.
Para asociarlo a una GUI hemos utilizado addItemListener(ItemListener oyente) de la GUI. Cuando el suceso es generado por GUI, se invoca el método itemStateChanged(ItemEvent e) del oyente asociado.

Hay que incluir:

import java.awt.event.*;

o

import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;


Los GUI awt para que pueda ser escuchado, son:

Checkbox
CheckboxMenuItem (no lo hemos visto. Es como un MenuItem, lo único es que funciona como una Checkbox, es decir, se puede clicar o no. Si se asocia a un CheckboxGroup, se convierte otra vez en un radiobutton, sólo que en un menú).
Choice
List

Además hemos visto los oyentes de los sucesos de las ventanas, es decir, los de tipo WindowListener.
Se asocian a las ventanas usando el método de éstas addWindowListener(WindowListener WL), y para definirlas hay que implementar la interfaz WindowListener y volver a definir los métodos:

void windowActivated(WindowEvent e), invocado cuando la ventana está activa, es decir, cuando aparece en primer plano en el desktop.
void windowClosed(WindowEvent e), invocado cuando la ventana se cierra.
void windowClosing(WindowEvent e), invocado cuando se aprieta el botón cerrarVentana (X).
void windowDeactivated(WindowEvent e), invocado cuando la ventana pasa a un segundo plano.
void windowDeiconified(WindowEvent e), invocado cuando la ventana se convierte de icono a activa.
void windowIconified(WindowEvent e), cuando se transforma en icono.
void windowOpened(WindowEvent e), cuando se abre.

Para escuchar los sucesos de la ventana hay que incluir:

import java.awt.event.WindowListener;
import java.awt.event.WindowEvent;


o

import java.awt.event.*;

Los sucesos de las ventanas se manifiestan casi siempre por parejas. Por ejemplo, cuando pulsamos la tecla X en la parte de arriba a la derecha de la ventana, primero se invoca windowClosing y después windowClosed, o cuando una ventana se transforma de icono a activa, primero escucha windowDeiconified y luego WindowActivated, etc.

Es posible escuchar sucesos de tipo ventana para los elementos:

Window
Frame
Dialog


Por lo que se refiere a los Dialog abro un paréntesis.
Son Frame sin icono. Reducir a icono y maximizar son muy parecidos para hacer precisamente unos diálogos rápidos con el usuario. Son, por ejemplo, unos dialog las ventanas que aparecen en las aplicaciones y dicen: ¿estás seguro de que quieres salir?
Un Dialog puede ser modal o no modal. El primero es un Dialog que bloquea completamente la aplicación y que, por tanto, ya no oye los sucesos, el segundo en cambio va en paralelo a ésta.
Los dialog de awt no pueden incluir menús, mientras que sí los incluyen los de swing (javax.swing.JDialog) si.

Vamos a ver qué sucesos pueden escuchar los objetos de tipo TextComponent, es decir, objetos de tipo TextField y TextArea. Podemos escuchar sucesos de tipo TextEvent, implementando la interfaz TextListener, y volviendo a definir el método textValueChanged(TextEvent e), invocado cada vez que el texto se modifica.
La interfaz y el suceso se encuentran en java.awt.event

Los objetos de tipo container, es decir, Panel, ScrollPane, Window (y, por lo tanto, Dialog y Frame), pueden escuchar los sucesos en el contenedor, utilizando el método addContainerListener(ContainerListener l). Hay que implementar la interfaz ContainerListener y volver a definir los métodos.

void componentAdded(ContainerEvent e)
void componentRemoved(ContainerEvent e)


Éstos se invocan automáticamente cuando se añaden o se quitan elementos al contenedor.
Hay que incluir java.awt.event.ContainerListener y java.awt.event.ContainerEvent.

Llegados a este punto vamos a ver qué sucesos se pueden escuchar en objetos de tipo Component, es decir, en TODOS los componentes awt, incluidos los contenedores y las ventanas.

En Component están los métodos:

addComponentListener(ComponentListener l)
addFocusListener(FocusListener l)
addHierarchyBoundsListener(HierarchyBoundsListener l)
addHierarchyListener(HierarchyListener l)
addInputMethodListener(InputMethodListener l)
addKeyListener(KeyListener l)
addMouseListener(MouseListener l)
addMouseMotionListener(MouseMotionListener l)
addPropertyChangeListener(PropertyChangeListener listener)
addPropertyChangeListener(String propertyName, PropertyChangeListener listener)

Los ComponentListener escuchan sucesos en el componente y hay que volver a definir los métodos.

void componentHidden(ComponentEvent e)
void componentMoved(ComponentEvent e)
void componentResized(ComponentEvent e)
void componentShown(ComponentEvent e)

Éstos se invocan cuando el componente se oculta, se mueve, cambia su tamaño y se visualiza.

FocusListener escucha los sucesos de focus del teclado en el componente, es decir, si se selecciona o no el componente del teclado.
Hay que volver a definir los métodos:

focusGained(FocusEvent e), invocado cuando se selecciona el componente.
focusLost(FocusEvent e), invocado por el componente cuando pierde la selección del teclado.

Pensemos, por ejemplo, en la navegación de las varias form de una interfaz, pulsando la tecla TAB.

HierarchyBoundsListener, escucha los sucesos de remoción de los antepasados del componente, por ejemplo, un botón en una ventana. Se implementa esta interfaz, escucha si la ventana se mueve.
Hay que volver a definir los métodos:

void ancestorMoved(HierarchyEvent e), invocada cuando el antepasado se remueve.
void ancestorResized(HierarchyEvent e) , invocada cuando se cambia de tamaño el antepasado.

HierarchyListener escucha los cambios de los antepasados del componente. Hay que volver a definir el método hierarchyChanged(HierarchyEvent e). Será HierarchyEvent el que incluye el cambio.

KeyListener ya lo hemos visto: escucha los sucesos del teclado. Hay que volver a definir los métodos.
void keyPressed(KeyEvent e), invocado cuando se tecla una tecla.
void keyReleased(KeyEvent e), invocado cuando se deja de teclear una tecla.
void keyTyped(KeyEvent e), invocado cuando se sigue pulsando una tecla.
En resumen, cuando se teclea una tecla se oyen los sucesos en éste orden: keyPressed, keyTyped y keyReleased.

MouseListener escucha los sucesos del ratón. Hay que volver a definir los métodos.
void mouseClicked(MouseEvent e), invocado cundo se clica un botón del ratón en el componente.
void mouseEntered(MouseEvent e), invocado cuando el ratón entra sobre el componente.
void mouseExited(MouseEvent e), invocado cuando el ratón sale del componente.
void mousePressed(MouseEvent e), invocado cuando se sigue teniendo pulsado el ratón sobre el componente.
void mouseReleased(MouseEvent e), invocado cuando se deja de pulsar el ratón.

MouseMotionListener, otros sucesos del ratón sobre el componente:
mouseDragged(MouseEvent e), invocado cuando se aprieta y se mueve el ratón sobre el componente.
void mouseMoved(MouseEvent e), invocado cuando el ratón se mueve sobre el componente, con o sin pulsar botones.

La última interfaz para los sucesos del ratón es MouseInputListener, que implementa las dos interfaces anteriores. Por lo tanto escucha todos los sucesos anteriores del ratón.

En el ejemplo a continuación se escuchan varios sucesos y se utiliza también un Dialog.

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

class escuchar extends Frame
{

Button b1=new Button("Botón1");

Button b2=new Button("Visualiza Dialog");

Button b3=new Button("salir");

Button b4=new Button("Cerrar Dialog");

Choice l1=new Choice();

TextField TF1=new TextField(15);

Dialog D;

AscoltaActionListener aal;
AscoltaItemListener ail;
AscoltaWindowListener awl;
AscoltaWindowListenerDialog awld;
AscoltaMouseListener aml;
AscoltaKeyListener akl;
public Ascolta()
{
setTitle("Frame, ejemplo oyentes suscesos");

setLocation(100,100);

setLayout(new GridLayout(5,1));
add(b1);
add(b2);
add(b3);
add(l1);
add(TF1);

D=new Dialog(this,true);
D.setSize(200,100);
D.setLocation(200,100);
D.add(b4,BorderLayout.SOUTH);
D.setTitle("Dialog - modale");
preparaD(false);

l1.add("Selección 1");
l1.add("Seleccióón 2");
l1.add("Selección 3");

// Inicializar los oyentes de los sucesos.
aal=new AscoltaActionListener();
ail=new AscoltaItemListener();
awl=new AscoltaWindowListener();
awld=new AscoltaWindowListenerDialog();
aml=new AscoltaMouseListener();
akl=new AscoltaKeyListener();
b1.addActionListener(aal);
b2.addActionListener(aal);
b3.addActionListener(aal);
TF1.addActionListener(aal);
l1.addItemListener(ail);
addWindowListener(awl);
addMouseListener(aml);
b1.addMouseListener(aml);
b2.addMouseListener(aml);
b3.addMouseListener(aml);
b4.addMouseListener(aml);
l1.addMouseListener(aml);
TF1.addMouseListener(aml);
TF1.addTextListener(new TextListener()
{
public void textValueChanged(TextEvent e)
{
System.out.println("TextListener: cambiar el valor de la TextField");
}
}
);
D.addMouseListener(aml);
addKeyListener(akl);
b1.addKeyListener(akl);
b2.addKeyListener(akl);
b3.addKeyListener(akl);
b4.addKeyListener(akl);
l1.addKeyListener(akl);
TF1.addKeyListener(akl);
D.addKeyListener(akl);
pack();
show();
}

void prepararD(boolean m)
{
D.setModal(m);
}

public static void main (String [] s)
{
System.out.println("Escuchar los sucesos.");
new Escuchar();

}

// ActionListener

class EscucharActionListener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{

String c=e.getActionCommand();
if (c.compareTo("Botón1")==0) System.out.println("ActionListener: Pulsar Botón1");
else
if (c.compareTo("Salir")==0)
{
System.out.println("ActionListener: Pulsar Salir");
System.exit(9); // es un número cualquiera, se llama exit code.
} else
if (c.compareTo("Visualizar Dialog")==0)
{
System.out.println("ActionListener: Pulsar Visualizar Dialog");
D.show();
b4.addActionListener(aal);
b2.removeActionListener(aal);
D.addWindowListener(awld);
} else
if (c.compareTo("Cerrar Dialog")==0)
{
System.out.println("ActionListener: Pulsar Visualizar Dialog");
D.hide();
b4.removeActionListener(aal);
b2.addActionListener(aal);
D.removeWindowListener(awld);
} else
{
System.out.println("ActionListener: Pulsar Enviar en la TextField, letto:"+TF1.getText());
TF1.setText("");
}

}
}

// ItemListener
class EscucharItemListener implements ItemListener
{

public void itemStateChanged(ItemEvent e)
{
String val=l1.getSelectedItem();
System.out.println("ItemListener: Seleccionado "+val);
}

}

// WindowListener

public class EscucharWindowListener implements WindowListener
{
public void windowActivated(WindowEvent e)
{
System.out.println("WindowListener: Ventana activada");
}

public void windowClosed(WindowEvent e)
{
System.out.println("WindowListener: Ventana cerrada");
}

public void windowClosing(WindowEvent e)
{
System.out.println("WindowListener: Pulsar cerrar ventana");
System.exit(0);
}

public void windowDeactivated(WindowEvent e)
{
System.out.println("WindowListener: Ventana no activada");
}

public void windowDeiconified(WindowEvent e)
{
System.out.println("WindowListener: Ventana sin icono");
}

public void windowIconified(WindowEvent e)
{
System.out.println("WindowListener: Ventana reducir a icono");
}

public void windowOpened(WindowEvent e)
{
System.out.println("WindowListener: Ventana abierta");
}
}


public class EscucharWindowListenerDialog implements WindowListener
{
public void windowActivated(WindowEvent e)
{
System.out.println("WindowListener: Dialog activado");
}

public void windowClosed(WindowEvent e)
{
System.out.println("WindowListener: Dialog cerrado");
}

public void windowClosing(WindowEvent e)
{
System.out.println("WindowListener: Pulsar cerrar Dialog");
D.hide();
b4.removeActionListener(aal);
b2.addActionListener(aal);
D.removeWindowListener(awld);
}

public void windowDeactivated(WindowEvent e)
{
System.out.println("WindowListener: Ventana no activada");
}

public void windowDeiconified(WindowEvent e)
{
System.out.println("WindowListener: Dialog sin icono");
}

public void windowIconified(WindowEvent e)
{
System.out.println("WindowListener: Dialog reducir a icono");
}

public void windowOpened(WindowEvent e)
{
System.out.println("WindowListener: Dialog abierto");
}
}

// Mouse Listener:
class EscucharMouseListener implements MouseListener
{

public void mouseClicked(MouseEvent e)
{
Component a=e.getComponent();
String n=a.getName();
System.out.println("MouseListener: Mouse clicado sobre el componente "+n);
}
public void mouseEntered(MouseEvent e)
{
Component a=e.getComponent();
String n=a.getName();
System.out.println("MouseListener: Mouse entrado en el componente "+n);
}
public void mouseExited(MouseEvent e)
{
Component a=e.getComponent();
String n=a.getName();
System.out.println("MouseListener: Mouse salido del componente "+n);
}
public void mousePressed(MouseEvent e)
{
Component a=e.getComponent();
String n=a.getName();
System.out.println("MouseListener: el botón está pulsado sobre el componente"+n);
}
public void mouseReleased(MouseEvent e)
{
Component a=e.getComponent();
String n=a.getName();
System.out.println("MouseListener: Mouse no está pulsado en el componente "+n);
}
}

// Teclado
class AscoltaKeyListener implements KeyListener
{
public void keyPressed(KeyEvent e)
{
System.out.println("KeyListener: Pulsar tecla "+e.getKeyChar()+
" codice "+
e.getKeyCode());
}
public void keyReleased(KeyEvent e)
{
System.out.println("KeyListener: Dejar de pulsar tecla "+e.getKeyChar()+
" codice "+
e.getKeyCode());
}
public void keyTyped(KeyEvent e)
{
System.out.println("KeyListener: Estás pulsando la tecla "+e.getKeyChar()+
" codice "+
e.getKeyCode());
}
}
}



  Volver al inicio de la página