UNIVERSIDAD NACIONAL DE TRUJILLO

ING. DE SISTEMAS

Interfaz Grfica de usuario (GUI): Manejo de

eventos

CURSO:
Tecnologa de la programacin.

INTEGRANTES:

- Guevara Torres, Stalin.

- Palomino Garca, Cristian.
- Ysla Riojas, Luis.

DOCENTE: Mg. Vidal Melgarejo, Zoraida

CICLO:
IV

GUADALUPE PER
2016
 TABLA DE CONTENIDO

INTERFAZ GRFICA DE USUARIO............................................................... 1

1. Definicin: ......................................................................................... 1
2. La interfaz grfica y el diseo visual con respecto al usuario:............ 2
INTERFAZ GRFICA DE USUARIO EN JAVA ............................................... 4
1. Componentes y contenedores: ..........................................................4
2. El AWT (Abstract Window Toolkit) .....................................................5
3. SWING ............................................................................................11
4. EVENTOS .......................................................................................18
BIBLIOGRAFA ............................................................................................. 29
 INTERFAZ GRFICA DE USUARIO

1. Definicin:

Una interfaz es el sistema de comunicacin entre el usuario y la

computadora. El medio por el cual le damos rdenes a la computadora y
ella nos devuelve el resultado de esas rdenes.
Recordemos que la computadora slo se comunica con 0 y 1. Una interfaz
traduce nuestras rdenes a 0 y 1 y viceversa, nos muestra la informacin
en una manera que podamos entender.
En informtica, el adelanto que hizo que la gente comn se aproximase a
las computadoras y que estas fuesen ms fciles de usar fue la Interfaz
Grfica de Usuario o GUI.
Las microcomputadoras se usaban con sistemas operativos que tenan
una interfaz de lnea de comandos. Esto exiga que el usuario tuviese
unos conocimientos previos un tanto extensos o un buen manual de
referencia al lado.

Una GUI hace el manejo de la computadora ms intuitivo usando

metforas grficas. Lo que en la interfaz de lnea de comandos se hace
escribiendo una orden, en la GUI se hace con una accin (en lugar de
escribir copy, arrastramos un elemento y lo ponemos en otra parte). Por
ejemplo, si en una interfaz de lnea de comandos escribimos DIR para
ver el contenido de una carpeta o directorio, en una GUI, tan slo hacemos
doble clic sobre el dibujo de la carpeta y se nos muestran los archivos
tambin por medio de imgenes.
En informtica, GUI es un conjunto de formas y mtodos que posibilitan a
los usuarios la interaccin con un sistema, empleando para esto grficos
e imgenes.
Con formas grficas nos referimos a botones, conos, ventanas, fuentes,
etc. los cuales representan funciones, acciones e informacin en el
contexto de ese sistema.

1
 No es el nico tipo de interfaz para usuarios, de hecho, el GUI surge de
una evolucin de la interfaz de lnea de comandos tradicional (llamada
tambin CLI) de los primeros sistemas operativos. El ejemplo ms
conocido es la familia de sistemas DOS (como MS-DOS). La interfaz de
lnea de comando an se emplea en mltiples casos porque en ocasiones
resulta conveniente.

2. La interfaz grfica y el diseo visual con respecto al usuario:

El diseo de la composicin visual y el comportamiento temporal de una

interfaz de usuario es una parte importante de la programacin de un
software de aplicacin o de un sistema operativo. El objetivo primordial
debe ser la eficiencia y la facilidad de uso para el usuario, esta disciplina
se llama usabilidad. Los diseos y mtodos de interaccin deben ser
centrados en el usuario, introduciendo elementos visuales y de textos
fciles de entender que sigan ciertos estndares.
Estos elementos visuales son llamados widgest, a continuacin, se
muestra un cuadro con una extensa variedad de elementos visuales GUI
comunes.
Elementos tpicos de las interfaces grficas de usuario (GUI)
Botn Men
Entrada de
contextual Menu (y Submen) Men
comandos
desplegable Men pastel (pie menu)
Casillero de verificacin Lista Lista
desplegable (combo box) Botn de
Entada/salida opcin (radio button) Cuadro de texto
de datos Grid view (datagrid) Botn de opcin
(Radio button) Barra de
desplazamiento (scrollbar)
Icono Barra de estado (status bar)
Informativos Globo de ayuda (ballon help) Barra de
progreso Barra de

2
 ttulo Slider Spinner Caja de texto
(Text box o Cuadro de texto) HUD
(heads-up) Infobar Etiqueta (label)
Splash screen Throbber Toast Tooltip
Ventana Acorden Ribbon Disclosure
widget (expansor oCombutcon) Cuadro
(frame/fieldset) Barra de men
Contenedores
(menubar) Panel Panel
lateral Pestaa (tab) Barra de
herramientas
De Barra de direcciones Breadcrumb
navegacin Hipervnculo Vista de rbol (treeview)
Acerca de (about box) Cuadro de
Ventanas dilogo (dialog box) Cuadro de dilogo
especiales de archivos Inspector window Modal
window Ventana de paleta
Relacionados Widget

3
 INTERFAZ GRFICA DE USUARIO EN JAVA

Las interfaces grficas de usuario (GUI) ofrecen al usuario ventanas, cuadros de

dilogo, barras de herramientas, botones, listas desplegables y muchos otros
elementos con los que ya estamos muy acostumbrados a tratar. Las aplicaciones
son conducidas por eventos y se desarrollan haciendo uso de las clases que
para ello nos ofrece la API de Java.
La API de Java proporciona 2 bibliotecas de clases para el desarrollo de
Interfaces grficas de usuario:

AWT
Swing

Las bibliotecas proporcionan un conjunto de herramientas para la construccin

de interfaces grficas que tienen una apariencia y se comportan de forma
semejante en todas las plataformas en las que se ejecuten.
La estructura bsica de la biblioteca gira en torno a componentes y
contenedores. Los contenedores contienen componentes y son componentes a
su vez, de forma que los eventos pueden tratarse tanto en contenedores como
en componentes. La API est constituida por clases, interfaces y derivaciones.

1. Componentes y contenedores:

A todos los elementos grficos que tenemos a disposicin para crear

GUIs, los llamamos componentes simplemente porque todos son
objetos de clases que heredan de la clase base COMPONENT. Algunos
ejemplos son button, list, textField, TextArea ,etc.En un GUI los
componentes son contenidos en contenedores o containers. Un
container es un objeto cuya clase hereda de CONTAINER (clase que a su
vez es subclase de COMPONENT) y tiene la responsabilidad de contener
componentes.
A continuacin, analizamos un extracto de la rama COMPONENT del
rbol de clases que provee java.

4
 En donde veremos que todas las clases heredan de COMPONENT quien
a su vez hereda de OBJECT. Las clases PANEL, WINDONW y FRAME
adems son containers porque heredan de CONTAINER.
Generalmente una GUI se monta sobre un Frame. Este ser el container
principal que contendr los componentes de la interfaz grfica.

2. El AWT (Abstract Window Toolkit)

Es un paquete en cual se encuentran las clases capaces de crear

componentes de la GUI; es decir, clases capaces de crear objetos
visuales sobre los cuales pueden los usuarios actuar, mediante el empleo
del ratn o el teclado, para comunicarse con el programa.
Los componentes de la GUI (botones, campos de texto, etc.) se organizan
en contenedores y esperan hasta que el usuario ejecute alguna accin
sobre ellos, es decir esperan un evento (suceso). Por eso se dice que la
programacin GUI es una programacin dirigida por eventos. Para el
diseo de este tipo de programas es necesario considerar, que las
interfaces graficas estn construidas por elementos grficos denominados
componentes agrupados dentro de otros que se denominan
contenedores, pero adems hay que tener en cuenta que los

5
 contenedores son a su vez componentes y pueden volver a ser agrupados
en otros contenedores. Habitualmente en un contenedor habr varios
componentes y para situarlos de forma conveniente pueden usarse los
administradores de diseos.
En resumen, las clases del paquete AWT pueden clasificarse en: grficos,
componentes, administradores de diseo, manipuladores de sucesos y
manipuladores de imgenes y para poder hacer uso de las mismas y
gestionar los eventos que se produzcan, los programas deben incluir las
siguientes sentencias:
Import java.awt.*;
Import java.awt.event.*;

1.1. Componentes y eventos soportados por el AWT de java:

Como todas las clases de java, los componentes utilizados en el

AWT pertenecen a una determinada jerarqua de clases, que es
muy importante conocer. Esta jerarqua de clases se muestra en la
siguiente imagen:

Todos los componentes descienden de la clase Component, de la

que pueden ya heredar algunos mtodos interesantes. El package
al que pertenecen estas estas clases se llama Java.awt.
A continuacin, se resumen algunas caractersticas importantes de
los componentes mostrados en la siguiente imagen:

6
 Jerarqua de eventos en java.

1.2. Componentes:
Los componentes se crean como cualquier otro objeto en java:
constructores.
Ejemplo:

Button boton = new Button();

Label etiqueta = new Label();
TextField campoTexto = new TextField();

Constructores: Cada tipo de componente tiene distintos tipos de

constructores.
.Ejemplo: Componente TextField
Campo de texto con tamao por defecto y en blanco.
TextField c = new TextField();
Campo de texto inicializado con un texto
TextField c = new TextField(Hola a todos);
Campo de texto con tamao 20 (tiene espacio para 20
caracteres)
TextField c = new TextField(20);
Campo de texto con tamao 20 e inicializado con un texto.
TextField c = new TextField(Hola, 20);
Mtodos ms comunes: Los componentes como todos los objetos
proporcionan mtodos que permiten manipular sus propiedades.
Eejmplo:

7
 Modificacin de la etiqueta de un botn.
boton.setLabel(Aceptar);
Consulta del texto de un campo de texto.
campo.getText();
Modificacin del texto de una etiqueta.
etiqueta.setText();
Insercin y consulta de elementos en una lista.
lista.add(Item1);
lista.add(Item2);
lista.getItem(2);
Activar o desactivar un botn.
boton.setEnabled(true);

1.3. Contenedores:

Tipos de contenedores:
A. Frame: La ventana tradicional de Windows (u otros S.O de
ventanas).
B. Dialog: Ventana que sirve para lanzar preguntas o advertencias al
usuario. No admite elementos como mens, barras de
herramientas, etc.

C. Panel: Contenedor que permite agrupar y organizar los elementos

de una ventana. Siempre se encuentra insertado dentro de un
Frame.
Algunos mtodos de los contenedores:
Asignacin de ttulo y tamao a una ventana.
ventana.setTitle(Titulo de la Ventana);
ventana.setSize(300,200);
Asignacin de color de fondo a un panel.
panel.setBackground(Color.blue);

8
 Ejemplo:
Ventana que posee un panel, dos etiquetas, un campo de texto, un
rea de texto y dos botones.
import java.awt.Frame;
import java.awt.Button;
import java.awt.TextField;
import java.awt.TextArea;
import java.awt.Panel;
import java.awt.Label;
public class MiVentana extends Frame {
Panel panelCentral;
TextField email;
Label etiqueta1;
Label etiqueta2;
TextArea mensaje;
Button enviar;
Button salir;
public MiVentana() {
panelCentral = new Panel();
email = new TextField(20);
mensaje = new TextArea(5,35);
etiqueta1 = new Label("Email:");
etiqueta2 = new Label("Escribe aqu tu Mensaje");
enviar = new Button("Enviar");
salir = new Button("Salir");
panelCentral.add(etiqueta1);
panelCentral.add(email);
panelCentral.add(etiqueta2);
panelCentral.add(mensaje);
panelCentral.add(enviar);
panelCentral.add(salir);
this.add(panelCentral);
this.setSize(300,225);
this.setTitle("Envo de Correo Electrnico"); this.show();
}

9
 public static void main(String[] args)
{
new MiVentana();
}

Este cdigo dara lugar a la siguiente ventana:

10
3. SWING

El paquete Swing es el nuevo paquete grfico que ha aparecido en la versin 1.2

de Java. Est compuesto por un amplio conjunto de componentes de interfaces
de usuario que funcionen en el mayor nmero posible de plataformas. Cada uno
de los componentes de este paquete puede presentar diversos aspectos y
comportamientos en funcin de una biblioteca de clases. En la versin 1.0 de
Swing, que corresponde a la distribuida en la versin 1.2 de la API de Java se
incluyen tres bibliotecas de aspecto y comportamiento para Swing:
metal.jar: Aspecto y comportamiento independiente de la plataforma.
motif.jar: Basado en la interfaz Sun Motif.
windows.jar: Muy similar a las interfaces Microsoft Windows 95.

3.1. Subpaquetes de Swing

A continuacin, se enumeran los paquetes que componen

Swing, as como su funcionalidad:
javax.swing: Tiene los componentes bsicos para crear
componentes ligeros Swing.
javax.swing.border: Para dibujar bordes personalizados en los
componentes Swing.

11
 javax.swing.colorchooser: Para utilizar el componente
JColorChooser.
javax.swing.event: Eventos lanzados por componentes Swing,
as como oyentes para dichos eventos. Extiende los que se
encuentran en el paquete AWT java.awt.event.
javax.swing.filechooser: Para utilizar el componente
JFileChooser.
javax.swing.plaf: Permite a Swing utilizar mltiples
representaciones. Se utiliza por aquellos desarrolladores que
no pueden crear un nuevo aspecto de interfaz, basado en los
que Swing ya incorpora (como Basic o Metal).
javax.swing.plaf.basic: Objetos que utilizan interfaces de
aspecto "Basic". Este aspecto es el que presentan por defecto
los componentes Swing. En este paquete se encuentran
gestores de impresin, eventos, oyentes y adaptadores. Se
puede crear un aspecto personalizado de interfaz utilizando
este paquete.
javax.swing.plaf.metal: Objetos que utilizan interfaces de
aspecto "Metal".
javax.swing.plaf.multi: Permite a los usuarios combinar
aspectos de interfaz, entre auxiliares y los que existen por
defecto.
javax.swing.text: Para manejar componentes de texto
(modificables o no). Soporta sintaxis resaltada, edicin,
estilos...
javax.swing.text.html: Contiene la clase HTMLEditorKit,
basada en la versin 3.2 de la especificacin HTML, y clases
para crear editores de texto HTML
javax.swing.text.html.parser: Contiene analizadores de texto
HTML javax.swing.text.rtf: Contiene la clase RTFEditorKit para
crear editores de documentos en formato RTF (Rich-Text-
Format).

12
 javax.swing.tree: Para personalizar la forma en que son
utilizados los rboles generados por la clase
java.awt.swing.JTree.
javax.swing.undo: Permite realizar operaciones de
deshacer/rehacer en las aplicaciones que cree el usuario.

3.2. Nuevas caractersticas

La arquitectura Swing presenta una serie de ventajas respecto a su

antecedente AWT:
Amplia variedad de componentes: En general las clases que
comiencen por "J" son componentes que se pueden aadir a la
aplicacin. Por ejemplo: JButton.
Aspecto modificable (look and feel): Se puede personalizar el
aspecto de las interfaces o utilizar varios aspectos que existen por
defecto (Metal Max, Basic Motif, Window Win32).
Arquitectura Modelo-Vista-Controlador: Esta arquitectura da lugar
a todo un enfoque de desarrollo muy arraigado en los entornos
grficos de usuario realizados con tcnicas orientadas a objetos.
Cada componente tiene asociado una clase de modelo de datos
y una interfaz que utiliza. Se puede crear un modelo de datos
personalizado para cada componente, con slo heredar de la
clase Model.
Gestin mejorada de la entrada del usuario: Se pueden gestionar
combinaciones de teclas en un objeto KeyStroke y registrarlo
como componente. El evento se activar cuando se pulse dicha
combinacin si est siendo utilizado el componente, la ventana en
que se encuentra o algn hijo del componente.
Objetos de accin (action objects): Estos objetos cuando estn
activados (enabled) controlan las acciones de varios objetos
componentes de la interfaz. son hijos de ActionListener.

13
 Contenedores anidados: Cualquier componente puede estar
anidado en otro. Por ejemplo, un grfico se puede anidar en una
lista.
Escritorios virtuales: Se pueden crear escritorios virtuales o
"interfaz de mltiples documentos" mediante las clases
JDesktopPane y InternalFrame.
Bordes complejos: Los componentes pueden presentar nuevos
tipos de bordes. Adems el usuario puede crear tipos de bordes
personalizados.
Dilogos personalizados: Se pueden crear multitud de formas de
mensajes y opciones de dilogo con el usuario, mediante la clase
JOptionPane.
Clases para dilogos habituales: Se puede utilizar JFileChooser
para elegir un fichero, y JColorChooser para elegir un color.
Componentes para tablas y rboles de datos: Mediante las clases
JTable y JTree.
Potentes manipuladores de texto: Adems de campos y reas de
texto, se presentan campos de sintaxis oculta JPassword, y texto
con mltiples fuentes JTextPane. Adems hay paquetes para
utilizar ficheros en formato HTML o RTF.
Capacidad para "deshacer": En gran variedad de situaciones se
pueden deshacer las modificaciones que se realizaron.
Soporte a la accesibilidad: Se facilita la generacin de interfaces
que ayuden a la accesibilidad de discapacitados, por ejemplo en
Braille.

3.3. Principales clases

Las clases de Swing se parecen mucho a las de AWT.

Pero todas las clases tienen una nueva versin en Swing con el
prefijo J. As la clase Panel de AWT tiene una clase JPanel en
Swing. Esto se cumple para todas las clases menos para Choice,
Canvas, FileDialgog y ScrollPane. De hecho todas las clases

14
 componentes de Swing (clases hijas de JComponent), son hijas de
la clase Component de AWT.
ButtonGroup: Muestra una lista de elementos
(JRadioButton) con solo uno seleccionable. Cada elemento
tiene un crculo, que en caso del elemento seleccionado
contendr un "punto".
JToggleButton: Es como un botn normal, pero al ser
pinchado por el usuario queda activado.
JProgressBar: Representa una barra de estado de progreso,
mediante la que habitualmente se muestra el desarrollo de
un proceso en desarrollo (ejemplo: la instalacin de una
aplicacin).
JTabbedPane: Es una ventana con solapas (la que utiliza
Windows). Este componente haba sido muy solicitado.
JApplet: Aunque ya exista una clase Applet en AWT, esta
nueva versin es necesaria para crear applets Java que
utilicen interfaces Swing.

3.4. Nuevos gestores de impresin

Swing incorpora nuevos gestores de impresin, ampliando los cinco

que AWT incorporaba. Entre ellos conviene destacar los siguientes:
BoxLayout: Es similar al FlowLayout de AWT, con la
diferencia de que con l se pueden especificar los ejes (x o y).
Viene incorporada en el componente Box, pero est
disponible como una opcin en otros componentes.
OverlayLayout: Todos los componentes se aaden encima de
cada componente previo.
SpringLayout: El espacio se asigna en funcin de una serie de
restricciones asociadas con cada componente.
ScrollPaneLayout: Incorporado en el componente ScrollPane.
ViewportLayout: Incorporado en el componente Viewport.

15
3.5. JrootPanel

La clase JRootPane permite colocar contenido de las applets

creadas con la clase JApplet en un determinado plano de impresin
(capa).
Por orden de cercana al usuario, estas capas son:
glassPane: Una capa que abarca toda la parte visible (por
defecto no es visible).
layeredPane: Una subclase de JComponent diseada para
contener cuadros de dilogo, mens emergentes y otros
componentes que deben aparecer flotando entre el usuario y
el contenido.
menubar: Una capa opcional, que si aparece estar anclada
en la parte superior.
contenPane: La capa en que se dibujar la mayor parte del
contenido.
As pues cada vez que se vayan a aadir componentes a una
applet de clase JApplet, debe aadirse a uno de estas capas.
Por ejemplo: laJApplet.getContentPane().add(
unComponente );

3.6. Nuevos eventos de Swing

Swing incorpora su nuevo conjunto de eventos para sus

componentes.
a. Eventos fsicos
Slo aparecen dos nuevos eventos fsicos, descendientes de
InputEvent:
MenuKeyEvent: Un men de rbol ha recibido un evento de
KeyEvent (accin sobre el ratn).
MenuDragMouseEvent: Un men de rbol ha recibido un
evento de
MouseEvent (pulsacin de una tecla).

16
 b. Eventos semnticos
Son todos hijos del evento de AWT AWTEvent, que es el evento
base de la jerarqua de eventos:
AncestorEvent: Antecesor aadido desplazado o eliminado.
CaretEvent: El signo de intercalacin del texto ha cambiado.
ChangeEvent: Un componente ha sufrido un cambio de
estado.
DocumentEvent: Un documento ha sufrido un cambio de
estado.
HyperlinkEvent: Algo relacionado con un vnculo hipermedia
ha cambiado.
InternalFrameEvent: Un AWTEvent que aade soporte para
objetos JInternalFrame.
ListDataEvent: El contenido de una lista ha cambiado o se ha
aadido o eliminado un intervalo.
ListSelectionEvent: La seleccin de una lista ha cambiado.
MenuEvent: Un elemento de men ha sido seleccionado o
mostrado o bien no seleccionado o cancelado.
PopupMenuEvent: Algo ha cambiado en JPopupMenu.
TableColumnModelEvent: El modelo para una columna de
tabla ha cambiando.
TableModelEvent: El modelo de una tabla ha cambiado.
TreeExpansionEvent: El nodo de un rbol se ha extendido o
se ha colapsado.
TreeModelEvent: El modelo de un rbol ha cambiado.
TreeSelectionEvent: La seleccin de un rbol ha cambiado de
estado.
UndoableEditEvent: Ha ocurrido una operacin que no se
puede realizar.

17
 3.7. Patrn de diseo Modelo-Vista-Controlador

Muchos de los componentes Swing estn basados en un patrn de

diseo denominado "Modelo-Vista-Controlador".
El concepto de este patrn de diseo se basa en tres elementos:
Modelo: Almacena el estado interno en un conjunto de clases.
Vista: Muestra la informacin del modelo
Controlador: Cambia la informacin del modelo (delegado).

4. EVENTOS
Cuando el usuario interacta con la interfaz grfica lo hace a travs de sus
componentes. Cada accin que realiza (esto es: cada botn que presiona, cada
tem que selecciona sobre una lista, cada carcter que escribe sobre un campo
de texto, etc.) genera un evento y nosotros, como programadores, lo podemos
escuchar para notificarnos y as poder hacer en ese momento lo que sea
necesario.
Es decir, los componentes generan eventos y nosotros podemos escucharlos
(o notificarnos) utilizando listeners (escuchadores). Un listener no es ms que un
objeto cuya clase implementa una determinada interface, que est relacionado
a un componente para que este lo notifica que ante la ocurrencia de un
determinado tipo de evento. Para analizar esto, comenzaremos por una GUI
bsica: una ventana con un nico botn que cuando lo apretamos escribe un
mensaje en la consola.

package libro.cap05;
import java.awt.*;
import java.awt.event.*;
public class DemoListener extends Frame
{
private Button boton;
public DemoListener()
{
super("Demo");

18
 setLayout(new FlowLayout());
boton = new Button("Boton");
// agrego un listener al botn
boton.addActionListener(new EscuchaBoton());
add(boton);
setSize(200,150);
setVisible(true);
}
class EscuchaBoton implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
System.out.println("Se presiono el boton...");
}
}
public static void main(String[] args)
{
new DemoListener();
}
}
En el constructor vemos que luego de instanciar el botn lo relacionamos con
una instancia de la inner class EscuchaBoton. Esta clase implementa la interface
ActionListener de donde hereda un nico mtodo: actionPerformed. Cuando el
botn detecte que lo estn presionando notificar a la instancia de EscuchaBoton
invocndole el mtodo actionPerformed.
Dicho de otro modo, cuando se presione el botn se invocar automticamente
el mtodo actionPerformed de la clase EscuchaBoton, por lo tanto, todo lo que
programemos dentro de este mtodo se ejecutar exactamente en el momento
en que el usuario apriete el botn. Es comn implementar los listeners como
inner classes de la GUI ya que, por lo general, las acciones que se programan
dentro de estos son propias y exclusivas para los componentes de la interfaz
grfica, por lo que muy difcilmente puedan ser reutilizados. A continuacin,
veremos un ejemplo ms simptico en el que cambiamos aleatoriamente la

19
ubicacin de la ventana cada vez que se presiona el botn. Solo veremos el
cdigo del listener ya que en la ventana principal no cambia nada.

class EscuchaBoton implements ActionListener

{
public void actionPerformed(ActionEvent e)
{
// dimension de la ventana
Dimension dimVentana = getSize();
// dimension de la pantalla
Dimension dimScreen = getToolkit().getScreenSize();
// nuevas coordenadas (aleatorias) para reubicar la ventana
int x= (int)(Math.random()*(dimScreen.width-dimVentana.width));
int y = (int)(Math.random()*(dimScreen.height-dimVentana.height));
// cambio la ubicacion de la ventana
setLocation(x,y);
}
}

Pensemos en un programa ms divertido. Cmo podramos lograr que la

ventana cambie de posicin cuando el mouse est llegando al botn para
presionarlo? Es decir, que el usuario nunca pueda apretar el botn porque ni bien
aproxime el mouse la ventana se mover a otra posicin. Para programar esto,
tenemos que escuchar el evento de movimiento del mouse. Por cada movimiento
del mouse, preguntamos sus coordenadas y las comparamos con las
coordenadas del botn. Si la distancia es razonablemente corta, entonces
movemos la ventana como lo hicimos en el ejemplo anterior.

package libro.cap05;
import java.awt.*;
import java.awt.event.*;
public class DemoListener3 extends Frame
{ private Button boton;

20
 public DemoListener3()
{
super("Demo");
setLayout(new FlowLayout());
// quien genera el evento es el Frame
addMouseMotionListener(new EscuchaMouse());
boton = new Button("Boton");
add(boton);
setSize(200,150);
setVisible(true);
}
class EscuchaMouse implements MouseMotionListener
{
public void mouseMoved(MouseEvent e)
{
int distancia = 10;
Point pMouse = e.getPoint();
Dimension dimBoton=boton.getSize();
Point pBoton = boton.getLocation();
int difX1 = Math.abs(pBoton.x-pMouse.x);
int difX2 = Math.abs((pBoton.x+dimBoton.width)-pMouse.x);
int difY1 = Math.abs(pBoton.y-pMouse.y);
int difY2 = Math.abs((pBoton.y+dimBoton.height)-pMouse.y);
if(difX1<distancia || difX2<distancia || difY1<distancia || difY2<distancia)
{
// dimension de la ventana
Dimension dimVentana = getSize();
// dimension de la pantalla
Dimension dimScreen = getToolkit().getScreenSize();
// nuevas coordenadas para la ventana
int y = (int) (Math.random()*(dimScreen.height-dimVentana.height));
int x= (int) (Math.random()*(dimScreen.width-dimVentana.width));
// cambio la ubicacion de la ventana

21
 setLocation(x,y);
}
}
public void mouseDragged(MouseEvent e) {}
}
public static void main(String[] args)
{
new DemoListener3();
}}
En este ejemplo escuchamos el evento que la ventana (el Frame) genera cada
vez que el mouse se mueve dentro de su rea. Por esto, le agregamos a la
ventana una instancia vlida de MouseMotionListener (o sea, una instancia de
EscuchaMouse). EscuchaMouse es una inner class que implementa
MouseMotionListener y sobrescribe los dos mtodos definidos en esta interface.
El mtodo mouseDragged lo dejamos vaco porque no nos interesa ser
notificados cuando el usuario arrastra el mouse (drag). Simplemente, queremos
saber cundo lo mueve. Dentro del mtodo mouseMoved, tomamos la posicin
del mouse, la posicin del botn y su dimensin para poder calcular la distancia
entre el mouse y los cuatro lados del botn. Si la distancia es menor que
distancia, entonces movemos la ventana.

5.1. Tipos de eventos:

3.1.1. Eventos de accin

Se consideran action events aquellos eventos a raz de los cuales

suponemos que el usuario espera producir una determinada accin.
Imaginemos que estamos ingresando nuestro nombre en un
TextField. Generalmente, mientras ingresamos cada carcter no
esperamos nada especial. Sin embargo, si al final presionamos
[ENTER] probablemente estemos esperando algo. O bien, si no
presionamos [ENTER], pero apretamos el botn que dice Ok
seguramente esperamos que algo suceda. Pensemos ahora en una
lista. Si hacemos click en un tem para seleccionarlo probablemente

22
no esperemos que nada demasiado emocionante ocurra, pero si
hacemos doble click sobre un tem entonces casi seguro que
estaremos esperando algn suceso. Analicemos la siguiente
interfaz grfica.

Demo de ActionListener.

En esta GUI el usuario puede tipear tems en el TextField de la

parte superior. Luego, presionando [ENTER] o presionando el
botn Agregar el texto ingresado pasar a la lista del centro. Para
eliminar elementos de la lista, se debe hacer doble click sobre el
tem que se quiere remover. Este tem pasar al TextField de forma
tal que si el usuario se arrepiente de haberlo eliminado puede
fcilmente volver a agregarlo a la lista presionando el botn o
tipeando [ENTER]. Veremos el cdigo fuente donde definimos dos
clases que implementan ActionListener. Una para la lista y una para
el botn y para el TextField, ya que al presionar [ENTER] sobre el
texteld o al presionar el botn se deben realizar exactamente las
mismas acciones. El listener debe ser el mismo.

package libro.cap05;
import java.awt.*;
import java.awt.event.*;

23
public class DemoListener5 extends Frame
{
private Button bAgregar;
private TextField tfItem;
private List lista;
public DemoListener5()
{
super("Action Listener");
// deno el layout principal
setLayout(new BorderLayout());
// al norte
Panel pn = _crearPNorte();
add(pn,BorderLayout.NORTH);
// al centro
lista= new List();
add(lista, BorderLayout.CENTER);
// seteo los listeners
bAgregar.addActionListener(new EscuchaAgregar());
tfItem.addActionListener(new EscuchaAgregar());
lista.addActionListener(new EscuchaDobleClick());
this.addWindowListener(new EscuchaVentana());
setSize(300,300);
setVisible(true);
// el cursor aparecera por defecto en el TextField
tfItem.requestFocus();
}
// sigue mas abajo
// :

En el constructor agregamos una instancia de EscuchaAgregar a

bAgregar (el botn) y a tfItem (el TextField). Tambin agregamos
una instancia de EscuchaDobleClick a lista. Veamos el cdigo de
la inner class EscuchaAgregar.

24
 // :
// viene de mas arriba
class EscuchaAgregar implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
// tomo el texto ingresado en el TextField
String item = tfItem.getText();
// lo agrego a la lista
lista.add(item);
// selecciono todo el texto en el TextField
tfItem.selectAll();
// seteo el foco en el TextField
tfItem.requestFocus();
}
}
// sigue mas abajo
// :
Veamos entonces para finalizar el cdigo de EscuchaDobleClick
// :
// viene de mas arriba
class EscuchaDobleClick implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
// tomo la posicion del item seleccionado
int idx = lista.getSelectedIndex();
// seteo el item selecciona en el TextField
tfItem.setText(lista.getSelectedItem());
// lo remuevo de la lista
lista.remove(idx);
// selecciono todo el texto del TextField

25
 tfItem.selectAll();
// seteo el foco en el TextField
tfItem.requestFocus();
}
}
// :
// aqui va la inner class EscuchaCerrar y el metodo _crearPNorte
// y el metodo main
// :
}
3.1.2. Eventos de teclado

Estos eventos los generan los TextField y los TextArea cada vez
que el usuario escribe un carcter sobre el componente. En la
siguiente ventana, el usuario puede escribir un texto en un
TextField. A medida que ingresa cada carcter lo vamos mostrando
en un Label ubicado a la derecha del TextField. Cuando finaliza e
ingresa [ENTER], mostramos el texto completo en el Label y
seleccionamos el texto en el TextField pasndolo a maysculas.

Demo KeyListener

Para esto, agregamos al TextField dos listeners: un ActionListener

para detectar el [ENTER] y un KeyListener para detectar cada vez
que el usuario presiona una tecla.
El cdigo es el siguiente:

package libro.cap05;

26
import java.awt.*;
import java.awt.event.*;
public class DemoListener6 extends Frame
{
private TextField tf;
private Label lab;
public DemoListener6()
{
super("Key Listener");
// deno el layout principal
setLayout(new FlowLayout(FlowLayout.LEFT));
add( new Label("Ingrese Texto:"));
tf= new TextField(15);
add(tf);
lab=new Label();
add(lab);
// agrego los listeners al TextField
tf.addKeyListener(new EscuchaTecla());
tf.addActionListener(new EscuchaEnter());
setSize(350,100); setVisible(true);
// mando el cursor al TextField
tf.requestFocus();
addWindowListener(new EscuchaVentana());
}
class EscuchaTecla implements KeyListener
{
public void keyPressed(KeyEvent e)
{
// por cada tecla presionada tomo el carcter
char c = e.getKeyChar();
// seteo el caracter como texto del label
lab.setText(Character.toString(c));
}

27
 public void keyReleased(KeyEvent e){}
public void keyTyped(KeyEvent e){}
}
class EscuchaEnter implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
// tomo el texto ingresado en el TextField
String texto = tf.getText();
// lo seteo como texto en el Label
lab.setText(texto);
// refresco los componentes de la ventana validate();
// combierto a mayuscula el texto del TextField
tf.setText(texto.toUpperCase());
// lo selecciono todo
tf.selectAll();
}
}
public static void main(String[] args)
{
new DemoListener6();
}
}

En la clase EscuchaEnter, luego de asignar el texto en lab

invocamos al mtodo validate (de Frame) para que haga el refresco
grfico de todos los componentes de la ventana, ya que si omitimos
este paso el texto del Label quedar trunco.

28
 BIBLIOGRAFA

Pablo Augusto Sznajdleder, Java a fondo : estudio del lenguaje y

desarrollo de aplicaciones . - 2a ed. -Buenos Aires : Alfaomega Grupo
Editor Argentino, 2013. Pag.161-190

DEITEL, PAUL J. Y HARVEY M. DEITEL, CMO PROGRAMAR EN

JAVA. Sptima edicin. Pag 422-526

29