Download Java - K ena

Manejo de eventos
Unidad IV
Tópico selectos de programación
Manejo de eventos con AWT (Abstract Windowing Toolkit)
La gestión de eventos a partir de la versión 2 de Java es conocida como modelo de delegación de eventos, que define mecanismos
coherentes y estándar para generar y procesar eventos. Una fuente genera un evento y lo envía a uno o más oyentes o auditores, que
han estado simplemente esperando hasta que reciben ese evento, y una vez recibido lo procesan y lo devuelven.
En un modelo de delegación de eventos, un auditor (u oyente) tiene que ir acompañado de una fuente para recibir la notificación de
un evento.
EVENTOS
Un evento es un objeto que describe un cambio de estado en una fuente. Se puede generar como una consecuencia de que una
persona interaccione con los elementos de una interfaz gráfica de usuario (GUI, por sus siglas en inglés). Algunas de las
actividades que hacen que se generen eventos son presionar botón, meter un carácter mediante el teclado, seleccionar un ítem
(elemento) de una lista, mover las barras de desplazamiento, y hacer click con el ratón, entre otras muchas cosas.
Puede ocurrir que no se provoque un evento directamente por la interacción con una interfaz de usuario (UI). Por ejemplo, se puede
generar un evento cuando se termina un cronómetro, cuando un contador pasa de un cierto valor, cuando hay un fallo de software o
de hardware, o cuando se acaba una operación. Se es libre de definir los eventos que uno considere mejores para una aplicación.
Fuentes de evento (source)
Una fuente es un objeto que genera un evento. Esto ocurre cuando cambia de alguna manera el estado interno de ese objeto. Las
fuentes pueden generar más de un tipo de evento.
Una fuente tiene que ir acompañada de auditores (oyentes (listener)) para que estos reciban notificaciones sobre el tipo específico
de evento. Cada tipo de evento tiene su propio método de registro. La forma general es:
public void addTipoListener(TipoListener objeto)
Donde tipo es le nombre del evento y objeto es una referencia al auditor (oyente). Por ejemplo, el método que registra o acompaña
a un oyente de teclado es addKeyListener(). El método que registra o acompaña a un oyente de movimiento de ratón es
addMouseMotionListener(). Cuando ocurre un evento, se notifica a todos los oyentes registrados, que reciben una copia del
objeto evento. Esto es lo que se conoce como multicasting del evento. En todos los casos, las notificaciones se envían solo a los
oyentes que quieren recibirlos.
Algunas fuentes sólo permiten registrar un oyente. La forma general del método de registro es:
public void addTipoListener(TipoListener objeto) throws java.util.TooManyListenersException
Cuando se produce el evento, se notifica al oyente que está registrado. Esto es conocido como unicasting del evento.
Una fuente también puede proporcionar un método que permita a un oyente eliminar un registro en un tipo específico de evento. La
forma general es:
public void removeTypeListener(TypeListener objeto)
Por ejemplo, para borrar un oyente de teclado, se llamaría a removeKeyListener().
La fuente que genera eventos es la que proporciona métodos para añadir o quitar oyentes de eventos del teclado o del ratón.
Maria Eugenia Puga Nathal
Página 1
08/08/2017
Manejo de eventos
La fuente de un evento, a parte de pulsar una tecla del teclado, o el movimiento, arrastre o el pulsar del botón de ratón, son los
componentes de la GUI tales como: botones, listas, campos y áreas de texto, barras de desplazamiento, menús, entre otros. Y como
ya se dijo, se detecta el evento de la fuente y se notifica al receptor (listener).
Auditores (oyentes o escuchas) de eventos (listener)
Un auditor u oyente es un objeto que es avisado cuando ocurre un evento. Tiene dos requisitos principales. Primero, tiene que ser
registrado o ir acompañado por una o más fuentes para recibir notificaciones sobre los tipos específicos de eventos. Segundo, tiene
que implementar métodos para recibir y procesar esas notificaciones.
Los métodos que reciben y procesan eventos se definen en un conjunto de interfaces que están en el paquete: java.awt.event por lo
que cada aplicación que requiera del manejo de eventos tendrá que importar a este paquete.
Como ya se comentó, para su registro:
fuente.addEventoListener(TipoEvento); por ejemplo:
boton.addActionListener(this); // en el objeto actual se programa el método actionPerformed(ActionEvent e){} de la interfaz
// ActionListener, y es donde se programan las acciones que se realizarán cuando se pulse el
// botón
frame.addWindowListener(new Cerrara); // se asocia a un objeto de la clase Frame, el evento de cerrar ventan, en la clase cerrar
// se programa éste
Clases de eventos
Como raíz en la jerarquía de clases de eventos Java está EventObject, que está en el paquete de java.util. Ésta es la superclase para
todos los eventos. Su constructor es el siguiente: EventObject(Object src)
Donde src es el objeto que genera ese evento.
EventObject contiene dos métodos: getSource() y toString(). El primero devuelve la fuente del evento. Su forma general es: Object
getSource(). El segundo, devuelve el String (cadena) correspondiente al evento.
La clase AWTEvent, definida dentro del paquete java.awt, es una subclase de EventObject. Ésta es la superclase de todos los
eventos basados en AWT utilizados por el modelo de delegación de eventos. Se puede usar su método getID() para determinar el
tipo de evento. Se escribe de esta manera: int getID()
Existen dos tipos de eventos:
De bajo nivel: representan una entrada de bajo nivel o suceso sobre un componente visual de un sistema de ventanas sobre la
pantalla. Eventos de Java comprendidos en este nivel:
- ComponentEvent
- FocusEvent
- InputEvent
- KeyEvent
- MouseEvent
- ContainerEvent
- WindowEvent
Evento semántico o de alto nivel: encapsula una acción de un componente de la interfaz del usuario. Eventos de Java comprendidos
en este nivel:
- ActionEvent
- AdjustmentEvent
- ItemEvent
- TextEvent
Maria Eugenia Puga Nathal
Página 2
08/08/2017
Manejo de eventos
Adaptadores
Cuando en un programa de Java se incluye la implementación de una interfaz, todos los métodos que la conforman deberán
desarrollarse dentro de éste, pero si alguno de esos métodos no se necesitan en la aplicación, aun así requieren de su
implementación, pero en este caso el cuerpo irá vacío. Las diferentes interfaces que se ofrecen en Java para la manipulación de
eventos, están compuestas por más de un método, y en ocasiones no se requiere de su implementación, pero debe cumplir con las
reglas establecidas para la implementación de las interfaces, por lo que deberá de aparecer dentro del programa, pero con el cuerpo
vacío como ya se comentó al inicio de este párrafo, Java para facilitarle al usuario la implementación de eventos, da otra
alternativa, que es implementar clases adaptadoras abstractas, las cuales ya contienen el desarrollo de los métodos contenidos en
las interfaces implementadas para el manejo de eventos, pero el cuerpo de estos métodos están vacíos, por lo que el usuario solo
implementará el método que necesitará, un ejemplo lo vimos en el manejo del cierre de la ventana, en este caso solo se requiere del
método windowClosing(), por lo que es el único que se reestructura. En la tabla que se localiza mas abajo, se presentan las
diferentes clases abstractas que permiten hacer la captación de los diferentes eventos que se pueden generar en una aplicación con
GUI.
Podemos generar una clase que herede de una clase adaptadora, en la cual solo implementemos el o los métodos que se vayan a
utilizar, por ejemplo:
class cerrar extends WindowAdapter
{public void windowClosing(WindowEvent e)
{System.exit(0);}
}
Esta clase habilita el evento de cerrar la ventana.
En la tabla que se presenta a continuación, se muestran las clases de eventos principales del paquete java.awt.event
Clase de evento
ActionEvent
Descripción
Se genera cuando se presiona un botón, se hace doble click en un elemento de una lista, o se selecciona un
elemento de menú.
AdjustmentEvent
Se genera cuando se manipula una barra de desplazamiento (scrollbar).
ComponentEvent
Se genera cuando un componente se oculta, se mueve, se cambia de tamaño, o se hace visible.
ContainerEvent
Se genera cuando se añade o se elimina un componente de un contenedor.
FocusEvent
Se genera cuando un componente gana o pierde el foco.
InputEvent
Superclase abstracta para cualquier clase de evento de entrada de componente.
ItemEvent
Se genera cuando se hace click en un checkbox (caja de verificación o de selección) o en un elemento de una
lista; también ocurre cuando se hace una selección en una opción (choice) o cuando se selecciona o
deselecciona un elemento de un menú de opciones.
KeyEvent
Se genera cuando se recibe una entrada desde el teclado.
MouseEvent
Se genera cuando el ratón se arrastra, se mueve, se hace click, se presiona, o se libera; también se genera
cuando el ratón entra o sale de un componente.
MouseWheelEvent
Se genera cuando se mueve la rueda del ratón.
TextEvent
Se genera cuando se cambia de valor de un área de texto o un campo de texto.
WindowEvent
Se genera cuando una ventana se activa, se cierra, se desactiva, se minimiza, se abre, o se sale de ella.
A continuación se presenta una tabla donde se muestra la clasificación de sucesos, oyentes, métodos y componentes
Maria Eugenia Puga Nathal
Página 3
08/08/2017
Manejo de eventos
Suceso
Oyente
Métodos
Componentes
ActionEvent
ActionListener
actionPerformed
Button
List
MenuItem
TextField
AdjustmentEvent
AdjustmentListener
adjustmentValueChanged
ScrollBar
ComponentEvent
ComponentListener
Component
ComponentAdapter
ContainerEvent
ContainerListener
Container
ContaneirAdapter
FocusEvent
FocusListener
Component
FocusAdapter
ItemEvent
ItemListener
componentHidden
componentMoved
componentResized
componentShown
componentAdded
componentRemoved
focusGained
focusLost
itemStateChanged
KeyEvent
KeyListener
Component
KeyAdapter
MouseEvent
MouseListener
keyPressed
keyReleased
keyTyped
mouseClicked
mouseEntered
mouseExited
mouseReleased
mousePressed
mouseDragged
mouseMoved
mouseWheelMoved
textValueChanged
windowActivated
windowDesactivated
windowOpened
windowClosed
windowClosing
windowIconified
windowDeiconified
Component
MouseAdapter
MouseMotionListener
MouseWheelEvent
TextEvent
WindowEvent
MouseWheelListener
TextListener
WindowListener
Adaptadores
CheckBox
Choice
List
MouseMotionAdapter
Component
TextComponent
Window
WindowAdapter
Cabe mencionar, que cada método recibirá como parámetro un objeto del tipo de suceso que puede generarse, por ejemplo:
public void windowClosing(WindowEvent e)
{// cuerpo}
public void mouseClicked(MouseEvent e)
{// cuerpo}
public void mouseMoved(MouseEvent e)
{// cuerpo}
public void keyPressed(KeyEvent e)
{// cuerpo}
Maria Eugenia Puga Nathal
Página 4
08/08/2017
Manejo de eventos
Clase ActionEvent
Se genera un objeto evento de la clase ActionEvent cuando se presiona un botón. Se hace doble click en un elemento de una lista, o
se selecciona algo de un menú. Esta clase define cuatro constantes enteras que se pueden utilizar para identificar cualquier
modificador asociado con este tipo de evento:
ALT_MASK
CTRL_MASK
META_MASK
SHIFT_MASK
La constante ACTION_PERFORMED puede ser utilizada para identificar eventos de acción.
ActionEvent tiene tres constructores:
ActionEvent(Object src, int tipo, String cmd)
ActionEvent(Object src, int tipo, String cmd, int modificador)
ActionEvent(Object src, int tipo, String cmd, long cuando, int modificador)
Donde src es una referencia al objeto que ha generado ese evento. El tipo de evento se especifica con tipo, y la cadena corresponde
a su comando cmd. El argumento modificador indica qué teclas modificadoras (ALT, CTRL, META y/o SHIFT) se han presionado
cuando se ha generado el evento. El parámetro cuando especifica cuando se ocurrió el evento.
Object getSource()  obtiene el nombre del objeto invocado
String getActionCommand ()  obtiene el nombre del comando del objeto invocado (etiqueta)
int getModifiers()
generado.
 devuelve un valor entero que indica qué tecla modificadora se ha presionado cuando el evento se ha
long getWhen()  devuelve el tiempo en el cual el evento tuvo lugar.
Clase AdjustmentEvent
Se genera un objeto evento de esta clase como resultado de un cambio sobre un scrollbar (barra de desplazamiento). Hay cinco
tipos de eventos de ajuste. Esta clase define cinco constantes enteras que se pueden utilizar para identificarlos.
BLOCK_DECREMENT
El usuario hace click dentro del srollbar para decrementar un valor
BLOCK_INCREMENT
El usuario hace click dentro del srollbar para incrementar su valor
TRACK
Se arrastra el botón movible del scrollbar
UNIT_DECREMENT
Se ha hecho click en el botón que está al final del scrollbar para decrementar su valor
UNIT_INCREMENT
Se ha hecho click en el botón que está al final del scrollbar para incrementar su valor
Existe otra constante entera, ADJUSTMENT_VALUE_CHANGED, que indica que ha ocurrido un cambio.
Esta clase tiene el siguiente constructor:
AdjustmentEvent(Adjustable src, int id, int tipo, int dato)
Donde src es una referencia al objeto que ha generado ese evento, el id es igual a ADJUSTMENT_VALUE_CHANGED, el tipo de
evento se especifica por tipo, y su dato asociado es dato.
Adjustable getAdjustable()  método que devuelve el objeto que ha generado el evento.
Maria Eugenia Puga Nathal
Página 5
08/08/2017
Manejo de eventos
int getAdjustmentType()  método que devuelve una de las constantes definidas por AdjustmentEvent, que indica el tipo de
ajuste generado.
int getValue()  método que devuelve la cantidad de ajuste, por ejemplo cuando se manipula un scrollbar, este método devuelve
el valor representado por ese cambio.
Clase ComponentEvent
Se genera un objeto evento de esta clase cuando cambia el tamaño, posición o visibilidad de un componente. Hay cuatro tipos de
eventos generados por un componente. Se definen cuatro constantes enteras que se pueden utilizar para identificarlos:
COMPONENT_HIDDEN
Se ha ocultado el componente.
COMPONENT_MOVED
Se ha movido el componente.
COMPONENT_RESIZED Se ha cambiado el tamaño del componente.
COMPONENT_SHOWN
El componente se ha hecho visible.
ComponentEvent(Component src, int tipo)  constructor de la clase
Donde src es una referencia al objeto que ha generado el evento. El tipo del evento se especifica a través de tipo.
ComponentEvent es la superclase de ContainerEvent, FocusEvent, KeyEvent, MouseEvent, y WindowEvent.
Component getComponent()  método que devuelve el componente que ha generado el evento.
Clase ContainerEvent
Se genera un objeto evento de esta clase cuando se añade o se borra un componente desde un contenedor. Hay dos tipos de eventos
generados por un contenedor, y que son definidos a través de dos constantes enteras: COMPONENT_ADDED y
COMPONENT_REMOVED. Éstas indican que se ha añadido o se ha borrado, respectivamente, un componente desde el
contenedor. Esta clase es una subclase de ComponentEvent.
ContainerEvent(Component src, int tipo, Component comp)  método constructor, donde src es una referencia al contenedor que
genera ese evento, el tipo de evento es especificado por tipo, y el componente que se ha añadido o borrado por comp.
Container getContainer()  método que permite obtener una referencia al contenedor que ha generado el evento.
Component getChild()  método que devuelve una referencia al componente que se ha añadido o se ha borrado desde el
contenedor.
Clase FocusEvent
Se genera un objeto evento de esta clase cuando un componente está o deja de estar activo. Estos eventos se identifican mediante
las constantes enteras: FOCUS_GAINED y FOCUS_LOST. Esta clase es una subclase de ComponentEvent.
Constructores:
FocusEvent(Component src, int tipo)
FocusEvent(Component src, int tipo, boolean bandera_temporal)
FocusEvent(Component src, int tipo, boolean bandera_temporal, Component otro)
Donde src es una referencia al componente que ha generado ese evento. El tipo del evento es especificado por tipo. El argumento
bandera_temporal es puesto en true si el evento foco es temporal, en cualquier otro caso se pone en false. Un evento foco temporal
se produce como resultado de otra operación de UI. Por ejemplo, supongamos que lo que está activo –tiene el foco- es un campo de
texto. Si el usuario mueve el ratón para modificar un scrollbar, se pierde temporalmente el foco.
Maria Eugenia Puga Nathal
Página 6
08/08/2017
Manejo de eventos
El otro componente envuelto en los cambios de foco, llamado el componente opuesto, se pasa en el argumento otro. Por lo tanto,
si un evento FOCUS_GAINED ocurre, otro hará referencia al componente que perdió el foco. Si un evento FOCUS_LOST ocurre,
otro hará una referencia al componente que obtuvo el foco.
Component getOppositeComponent()  este método devuelve el componente otro.
boolean isTemporary()  método que indica si este cambio de foco es temporal. Regresa true si el cambio es temporal, en caso
contrario, regresa false.
Clase InputEvent
Clase abstracta que es superclase para los eventos de entrada de componentes, y a su vez es una subclase de ComponentEvent. Sus
subclases son KeyEvent y MouseEvent.
InputEvent define ocho constantes enteras, que se pueden utilizar para obtener información sobre cualquier modificador asociado
con el evento:
ALT_MASK
BUTTON2_MASK
META_MASK
ALT_GRAPH_MASK
BUTTON3_MASK
SHIFT_MASK
BUTTON1_MASK
CTRL_MASK
Dado que generaba conflictos entre los modificadores (constantes) utilizados por eventos de teclado y de ratón con otros eventos,
se hizo una extensión de estas constantes:
ALT_DOWN_MASK
ALT_GRAPH_DOWN_MASK
BUTTON1_DOWN_MASK
BUTTON2_DOWN_MASK
BUTTON3_DOWN_MASK
CTRL_DOWN_MASK
META_DOWN_MASK
SHIFT_DOWN_MASK
Los métodos que vienen a continuación se utilizan para cuando se desea verificar si un modificador fue presionado en el momento
en que un evento se genera:
boolean
boolean
boolean
boolean
boolean
isAltDown()
isAltGraphDown()
isControlDown()
isMetaDown()
isShiftDown()
comprueban si esos modificadores se han presionado al mismo tiempo que se ha generado el evento.
int getModifiers()  método que devuelve un valor que contiene todas las etiquetas de los modificadores para ese evento.
int getModifiersEx()  método que devuelve un valor que contiene todas las etiquetas de los modificadores extendidos para ese
evento.
Clase ItemEvent
Se genera un objeto evento de esta clase cuando se hace click en un checkbox o en un elemento de una lista o cuando se selecciona
o se deselecciona un elemento de un menú de opciones. Hay dos tipos de eventos de elementos, que se identifican por las
siguientes constantes enteras:
DESELECTED
El usuario deselecciona un elemento.
SELECTED
El usuario selecciona un elemento.
Además se define una constante entera ITEM_STATE_CHANGED, que significa un cambio de estado.
ItemEvent(ItemSelectable src, int tipo, Object entrada, int estado)  método constructor de la clase, donde src es una referencia
al componente que ha generado ese evento, el tipo de elemento es especificado por tipo, lo que específicamente genera le evento es
pasado entrada y el estado actual del elemento con estado.
Maria Eugenia Puga Nathal
Página 7
08/08/2017
Manejo de eventos
Object getItem()  este método se puede utilizar para obtener una referencia al elemento que ha generado un evento.
ItemSelectable getItemSelectable()  método que se puede utilizar para obtener una referencia al objeto ItemSelectable que ha
generado un evento.
Las listas (List) y las listas desplegables (Choice) son ejemplos de elementos de UI que implementan la interfaz ItemSelectable.
int getStateChange()  método que devuelve el cambio de estado (por ejemplo, SELECTED o DESELECTED) para el evento.
Clase KeyEvent
Se genera un objeto evento de esta clase cuando se pulsa una tecla. Hay tres clases de eventos de teclado, que están definidos por
las constantes enteras: KEY_PRESSED, KEY_RELEASED y KEY_TYPED. Los primeros dos eventos se generan cuando se
presiona o se libera cualquier tecla. El tercer evento sólo se da cuando se genera un carácter.
KeyEvent define otras constantes enteras, por ejemplo, VK_0 a VK_9 y VK_A a VK_Z definen los caracteres ASCII equivalente
de números y letras mayúsculas. VK_F1 a VK_24 teclas de funciones, VK_NUMPAD0 a VK_NUMPAD9, las teclas numéricas.
Algunas otras constantes son (http://java.sun.com/javase/6/docs/api/index.html):
VK_ENTER
VK_DOWN
VK_LEFT
VK_RIGHT
VK_UP
VK_PAGE_UP
VK_PAGE_DOWN
VK_ESCAPE
VK_SHIFT
VK_CANCEL
VK_ALT
VK_CONTROL
VK_AMPERSAND
VK_ASTERISK
VK_AT
(@)
VK_SPACE
VK_BEGIN
VK_END
VK_BACK_SLASH (\)
VK_BACK_SPACE
VK_SLASH
(/)
VK_CAPS_LOCK
VK_NUM_LOCK
VK_CIRCUMPLEX (^)
VK_EQUALS (=)
VK_INSERT
VK_NUMBER_SIGN (#)
VK_OPEN_BRACKET ( [ )
VK_CLOSE_BRACKET ( ] )
VK_COLON (:)
VK_COMMA (,)
VK_PERIOD (.)
VK_SEMICOLON(;)
VK_LEFT_PARENTHESIS
VK_RIGHT_PARENTHESIS
VK_PRINTSCREEN
Las constantes VK especifican códigos de teclas virtuales y son independientes de cualquier modificador, como control, shift o alt.
KeyEvent es una subclase InputEvent.
Constructores:
KeyEvent(Component src, int tipo, long when, int modificador, int code)
KeyEvent(Component src, int tipo, long when, int modificador, int code, char ch)
Donde src es la referencia al componente que genera el evento, el tipo de evento está referenciado por tipo, el momento en que se
ha presionado la tecla se pasa con when, los argumentos modificador indican qué modificador se ha presionado cuando ha ocurrido
ese evento del teclado, el código de tecla virtual, como VK_UP, VK_A, y así sucesivamente, se pasa con code. El carácter
equivalente (si existe alguno) se pasa con ch. Si no existe ningún carácter válido, entonces ch contienen a CHAR_UNDEFINED.
Para los eventos KEY_TYPED, conde contendrá a VK_UNDEFINED.
Esta clase tiene varios métodos definidos pero los más usuales son:
char getKeyChar()  que devuelve el carácter que se ha tecleado
int getKeyCode()  que devuelve el código de la tecla
Si no hay disponible carácter válido alguno, getKeyChar() devuelve CHAR_UNDEFINED. Cuando se produce un evento
KEY_TYPED, getKeyCode() devuelve VK_UNDEFINED.
Clase MouseEvent
Hay ocho eventos de ratón. Esta clase define las siguientes constantes enteras, que se pueden utilizar para identificarlos:
MOUSE_CLICKED
El usuario hace click con el ratón.
Maria Eugenia Puga Nathal
Página 8
08/08/2017
Manejo de eventos
MOUSE_DRAGGED
El usuario arrastra el ratón.
MOUSE_ENTERED
El ratón mete un componente.
MOUSE_EXITED
El ratón sale de un componente.
MOUSE_MOVED
Se mueve el ratón.
MOUSE_PRESSED
Se presiona el ratón.
MOUSE_RELEASED
Se libera el ratón
MOUSE_WHEEL
La rueda del ratón fue movida
MouseEvent es una subclase de InputEvent
MouseEvent(Componet scr, int tipo, long when, int modificador, int x, int y, int clicks, boolean triggersPopup)
Donde src es la referencia al componente que genera el evento, el tipo de evento está referenciado por tipo, el momento en que se
ha presionado la tecla se pasa con when, el argumento modificador indica qué modificador se ha presionado cuando ha ocurrido un
evento del ratón, las coordenadas del ratón se pasan con x e y, el número de clicks se pasa con clicks, el atributo triggersPopup
indica si ese evento hace que aparezca un menú en esa plataforma.
int getX()  Devuelve la coordenada de x el ratón cuando ha ocurrido el evento.
int getY()  Devuelve la coordenada de y el ratón cuando ha ocurrido el evento.
Point getPoint()  obtiene las coordenadas del ratón, pero en este caso las almacena en un objeto de la clase Point.
void translatePoint(int x, int y)  traduce la posición del evento. Los valores de x e y se añaden a las coordenadas del evento.
int getClickCount()  da el número de clicks que han hecho con el ratón para ese evento.
boolean isPopupTrigger()  prueba si el evento ha hecho aparecer un menú en la plataforma.
int getButton()  devuelve el valor que representa el botón que causa el evento. El valor devuelto será una de las constantes
definidas por MouseEvent: NOBUTTON, BUTTON1, BUTTON2, BUTTON3
NOBUTTON indica que no hay botón presente o liberado.
Point getLocationOnScreen()  devuelve un objeto Point que contiene las dos coordenadas X y Y, éstas serán relativas a la
pantalla y no al componente.
int getXOnScreen()  devuelve la coordenada X, ésta será relativa a la pantalla y no al componente.
int getYOnScreen()  devuelve la coordenada Y, ésta será relativa a la pantalla y no al componente.
Clase MouseWheelEvent
Esta clase encapsula un evento de la rueda del ratón. Es una subclase de MouseEvent. Define dos constantes enteras:
WHEEL_BLOCK_SCROLL
Un evento de página arriba o página abajo ocurrió
WHEEL_UNIT_SCROLL
Un evento de línea arriba o línea abajo ocurrió
MouseWheelEvent(Component src, int tipo, long when, int modificadores, int x, int y, int clics, boolean t, int sc, int monto, int
cuenta)  uno de los métodos constructores, donde src es una regencia al objeto que genera el evento, el tipo de evento se
Maria Eugenia Puga Nathal
Página 9
08/08/2017
Manejo de eventos
especifica en tipo, la hora en que el evento del ratón ocurrió se pasa en when, el argumento modificadores indica cuales
modificadores fueron activados cuando el evento ocurrió. Las coordenadas del ratón se pasan a través de x y y, el número de clicks
que la rueda ha rotado se pasa mediante clics, t es una bandera que indica si ese evento causa que un menú popup (emergente)
aparezca en esta plataforma. El valor sc debe ser WHEEL_BLOCK_SCROLL o WHEEL_UNIT_SCROLL. El número de
unidades de scroll es pasado en monto, cuanta indica el número de rotaciones en que la rueda se movio.
int getWheelRotation()  método que regresa el número de unidades rotacionales. Si el valor es positivo, la rueda se movió en
contra de las manecillas del reloj, y si es negativo, la rueda se movió en el sentido de las manecillas del reloj.
int getScrollType()
 devuelve WHEEL_BLOCK_SCROLL o WHEEL_UNIT_SCROLL.
WHEEL_UNIT_SCROLL, se puede obtener el número de unidades de scroll llamando al método:
int getScrollAmount()
Si
el
tipo
es
Clase TextEvent
Se genera mediante campos de texto y áreas de texto cuando el usuario o el programa introducen caracteres. Se define la contante
entera TEXT_VALUE_CHANGED.
TextEvent(Object src, int tipo)
referenciado por tipo.
 donde src es la referencia al componente que genera el evento, el tipo de evento está
El objeto TextEvent no incluye los caracteres que ya están en el componente de texto que ha generado el evento, sino que el
programa es el que tiene que utilizar otros métodos asociados con el componente de texto para recuperar la información.
Clase WindowEvent
Hay diez tipos de eventos de ventanas. Se definen constantes enteras que se pueden utilizar para identificarlos:
WINDOW_ACTIVATED
Se ha activado la ventana.
WINDOW_CLOSED
Se ha cerrado la ventana.
WINDOW_CLOSING
El usuario ha pedido que se cierre la ventana.
WINDOW_DEACTIVATED
La ventana ha dejado de estar activa.
WINDOW_DEICONIFIED
Se ha mostrado la ventana tras pulsar su icono.
WINDOW_GAINED_FOCUS
La ventana ahora está en foco de entrada.
WINDOW_ICONIFIED
Se ha minimizado la ventana a un icono.
WINDOW_LOST_FOCUS
La ventana ha perdido el foco de entrada.
WINDOW_OPENED
Se ha abierto la ventana.
WINDOW_STATE_CHANGED
El estado de la ventana ha cambiado.
WindowEvent es una subclase de ComponentEvent.
Constructores:
WindowEvent(Window src, int tipo) // éste es el más básico
WindowEvent(Window src, int tipo, Window otro)
WindowEvent(Window src, int tipo, Window otro, int deEstado, int aEstado)
Donde src es la referencia al componente que genera el evento, el tipo de evento está referenciado por tipo, otro especifica la
ventana opuesta cuando un evento de foco o activación ocurre. El parámetro deEstado especifica el estado anterior de la ventana, y
aEstado el nuevo estado que tendrá cuando un cambio de estado de ventana ocurre.
Maria Eugenia Puga Nathal
Página 10
08/08/2017
Manejo de eventos
Window getWindow()  devuelve el objeto Window que ha generado el evento.
Window getOppositeWindow()  devuelve la ventana contraria (cuando un evento de foco o activación ha ocurrido).
int getOldState()  devuelve el estado anterior de la ventana.
int getNewState()  devuelve el estado actual de la ventana.
Ejemplos de componentes que pueden generar eventos
Origen de evento
Button
Descripción
Genera eventos de acción (ActionEvent) cuando se presiona el botón.
Checbox
Genera eventos de elemento (ItemEven) cuando se selecciona o deselecciona un checkbox.
Choice
Genera eventos de elemento (ItemEven) cuando se cambia una opción (choice).
List
Genera eventos de acción (ActionEvent) cuando se hace doble click sobre un elemento; genera eventos de
elemento (ItemEvent) cuando se selecciona o se deselecciona un elemento.
MenuItem
Genera eventos de acción (ActionEvent) cuando se selecciona un elemento de menú; genera eventos de
elemento (ItemEvent) cuando se selecciona o deselecciona un elemento de un menú de opciones.
Scrollbar
Genera eventos de ajuste (AdjustmentEvent) cuando se manipula el scrollbar.
TextComponent
Genera eventos de texto (TextEvent) cuando el usuario introduce un carácter.
Window
Genera eventos de ventana (WindowEvent) cuando una ventana se activa, se cierra, se desactiva, se
minimiza, se maximiza, se abre o se sale de ella.
Interfaces de auditores (listener) de eventos
En la tabla que se presenta a continuación, se muestran las interfaces listener (auditor, oyente) principales del paquete
java.awt.event
Oyente (listener)
ActionListener
AdjustmentListener
ComponentListener
Descripción
Define un método para recibir eventos de acción.
Define un método para recibir eventos de ajuste.
Define cuatro métodos para reconocer cuándo se
oculta, se mueve, se cambia de tamaño o se muestra
un componente.
ContainerListener
Define dos métodos para reconocer cuándo se añade
o se elimina un componente de un contenedor.
Define dos métodos para reconocer cuándo un
componente gana o pierde el foco del teclado.
Define un método para reconocer cuándo cambia de
estado un elemento.
Define tres métodos para reconocer cuándo se
presiona, se libera o se golpea una tecla.
FocusListener
ItemListener
KeyListener
MouseListener
Define cinco métodos para reconocer cuándo se
presiona o libera un botón del ratón, se hace clic con
él, o el ratón entra en un componente o sale de él
Maria Eugenia Puga Nathal
Página 11
Métodos
actionPerformed(ActionEvent e)
adjustmentValueChanged (AdjustmentEvent e)
componentHidden(ComponentEvent e)
componentMoved(ComponentEvent e)
componentResized(ComponentEvent e)
componentShown(ComponentEvent e)
componentAdded(ContainerEvent e)
componentRemoved(ContainerEvent e)
focusGained(FocusEvent e)
focusLost(FocusEvent e)
itemStateChanged(ItemEvent e)
keyPressed(KeyEvent e)
keyReleased(KeyEvent e)
keyTyped(KeyEvent e)
mouseClicked(MouseEvent e)
mouseEntered(MouseEvent e)
mouseExited(MouseEvent e)
mouseReleased(MouseEvent e)
mousePressed(MouseEvent e)
08/08/2017
Manejo de eventos
MouseMotionListener
MouseWheelListener
TextListener
WindowFocusListener
WindowListener
Define dos métodos para reconocer cuándo se
arrastra o se mueve el ratón.
Define un método para reconocer cuándo la rueda del
ratón se mueve.
Define un método para reconocer cuándo cambia un
valor de texto.
Define dos métodos para reconocer cuándo una
ventana gana o pierde foco de entrada.
Define siete métodos para reconocer cuándo una
ventana se activa, se cierra, se desactiva, se
minimiza, se maximiza, se abre o se sale de ella.
mouseDragged(MouseEvent e)
mouseMoved(MouseEvent e)
mouseWheelMoved(MouseWheelEvent e)
textValueChanged(TextEvent e)
windowGainedFocus (WindowEvent e)
windowLostFocus(WindowEvent e)
windowActivated(WindowEvent e)
windowDesactivated(WindowEvent e)
windowOpened(WindowEvent e)
windowClosed(WindowEvent e)
windowClosing(WindowEvent e)
windowIconified(WindowEvent e)
windowDeiconified(WindowEvent e)
Ejemplos:
eventos del ratón
La clase EventosRaton hereda de la clase Frame e implementa los métodos de las interfaces: MouseListener,
MouseMotionListener. Lo único que hace es mostrar en una etiqueta los diferentes eventos del ratón y la posición de éste.
import java.awt.*;
import java.awt.event.*; // se importa el paquete para el manejo de eventos
public class EventosRaton extends Frame implements MouseListener, MouseMotionListener
{ Label edo; // declara un objeto de la clase Label (etiqueta)
public EventosRaton() // método constructor
{super ("ejemplo de eventos del raton"); // llama a la superclase (Frame) y pone titulo al Frame
edo=new Label(); // crea el objeto edo, que es una instancia de la clase Label (etiqueta)
add(edo,BorderLayout.SOUTH); // añade la etiqueta al Frame
addMouseListener(this); // activa el escucha de los eventos del raton
addMouseMotionListener(this); // activa el escucha de los eventos del raton
setSize(600,600); // tamaño del Frame
setVisible(true); // hace visible al Frame
}
// métodos que están contenidos en la interface MouseListener, invocados por el método escucha
// addMouseListener(this);
// e.getX(),e.getY(), obtienen las coordenadas del raton
public void mouseClicked(MouseEvent e)
{ edo.setText("click "+e.getX()+","+e.getY()); }
public void mousePressed(MouseEvent e)
{ edo.setText("presiono "+e.getX()+","+e.getY()); }
public void mouseReleased(MouseEvent e)
{ edo.setText("suelto "+e.getX()+","+e.getY()); }
public void mouseEntered(MouseEvent e)
{ edo.setText("entro "+e.getX()+","+e.getY()); }
public void mouseExited(MouseEvent e)
{ edo.setText("salgo "+e.getX()+","+e.getY()); }
Maria Eugenia Puga Nathal
Página 12
08/08/2017
Manejo de eventos
// métodos que están contenidos en la interface MouseMotionListener, invocados por el método escucha
// addMouseMotionListener(this);
public void mouseDragged(MouseEvent e)
{ edo.setText("arrastro "+e.getX()+","+e.getY()); }
public void mouseMoved(MouseEvent e)
{ edo.setText("muevo "+e.getX()+","+e.getY()); }
public static void main (String arg[])
{EventosRaton er=new EventosRaton();
er.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {System.exit(0);} });
}
}
Este es el mismo ejemplo anterior, pero le agregue algunas cosas, como por ejemplo, que cambie de color el fondo según el evento
generado, y que cuando se arrastre el ratón lo siga la cadena H o o o o l a ! ! !
import java.awt.*;
import java.awt.event.*;
public class EventosRaton2 extends Frame implements MouseListener, MouseMotionListener
{ Label edo;
int x, y;
public EventosRaton2()
{super ("ejemplo de eventos del raton");
edo=new Label();
add(edo,BorderLayout.SOUTH);
addMouseListener(this);
addMouseMotionListener(this);
setSize(600,600);
setVisible(true);
x=y=0;
}
// con el metodo setBackground() cambio de color las areas libres del Frame
public void mouseClicked(MouseEvent e)
{ edo.setText("click"+e.getX()+","+e.getY());setBackground(Color.pink); }
public void mousePressed(MouseEvent e)
{ edo.setText("presiono"+e.getX()+","+e.getY());setBackground(Color.red); }
public void mouseReleased(MouseEvent e)
{ edo.setText("suelto"+e.getX()+","+e.getY());setBackground(Color.blue); }
public void mouseEntered(MouseEvent e)
{ edo.setText("entro"+e.getX()+","+e.getY());setBackground(Color.black); }
public void mouseExited(MouseEvent e)
{ edo.setText("salgo"+e.getX()+","+e.getY());setBackground(Color.yellow); }
public void mouseDragged(MouseEvent e)
{ edo.setText("arrastro"+(x=e.getX())+","+(y=e.getY()));setBackground(Color.green);
repaint();
}
public void mouseMoved(MouseEvent e)
{ edo.setText("muevo"+e.getX()+","+e.getY());setBackground(Color.gray); }
public void paint(Graphics g)
Maria Eugenia Puga Nathal
Página 13
08/08/2017
Manejo de eventos
{g.drawString("H o o o o l a ! ! !",x,y);
}
public static void main (String arg[])
{EventosRaton2 er=new EventosRaton2();
er.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {System.exit(0);} });
}
}
Pueden crear la clase siguiente, y solo generar un objeto de ella en las aplicaciones y ya tienen incorporado el evento para cerrar la
ventana gráfica.
import java.awt.event.*;
public class CerrarVentana extends WindowAdapter
{public void windowClosing(WindowEvent e)
{System.exit(0);}
}
El ejemplo que se muestra a continuación es un applet, en el cual cada vez que arrastramos el raton se dibuja una línea, y una vez
que terminado de hacerlo, desaparece ésta. En este ejemplo se crea un objeto anónimo de la clase CerrarVentana, además de
implementar el método main() para que la clase se comporte tanto como un applet como una aplicación independiente.
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class Linea extends Applet implements MouseListener, MouseMotionListener
{int x1=0, y1=0;
int x2=0, y2=0;
boolean draw;
public void init() // si se tratara de una clase que hereda de clase Frame y no de Applet, éste sería el método constructor
{addMouseListener(this);
addMouseMotionListener(this);
draw=false;
}
// los métodos que vienen a continuación, quedan con el cuerpo vacío ya que no se utilizaran en esta aplicación, pero como
// indicamos en la clase que se va a implementar las interfaces MouseListener y MouseMotionListener, es necesario
// implementar los métodos correspondientes a cada interface, se necesiten o no en la aplicación, si no se necesitan quedan
// con el cuerpo vacío como los casos siguientes:
// métodos de la interface MouseListener
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
public void mousePressed(MouseEvent e)
{x2=e.getX();
y2=e.getY();
draw=true;
}
public void mouseReleased(MouseEvent e)
{draw=false;}
Maria Eugenia Puga Nathal
Página 14
08/08/2017
Manejo de eventos
// interface MouseMotionListener, ésta contiene solo dos métodos, los cuales si se utilizarán en este ejemplo, por lo tanto
// el cuerpo no estará vacío
public void mouseDragged(MouseEvent e)
{x1=e.getX();
y1=e.getY();
repaint();
}
public void mouseMoved(MouseEvent e)
{showStatus("Moviendo mouse en: "+e.getX()+","+e.getY());}
public void paint(Graphics g)
{if (draw) {g.drawLine(x1,y1,x2,y2);}
}
// opcional, ya que es un applet, se pone esto si quieren que se ejecute también como una aplicación.
public static void main (String arg[])
{Frame f=new Frame("Otro ejemplo de eventos de raton");
Linea linea=new Linea();
f.add(linea);
linea.init();
f.addWindowListener(new CerrarVentana()); // se crea un objeto anónimo de la clase CerrarVentana
f.setSize(600,600);
f.setVisible(true);
}
}
Código de la página html
<html>
<applet code=”Linea.class” width=600 height=600>
</applet>
</html>
Mismo ejemplo que el anterior, la diferencia es que en éste se implementan los dos métodos de la interface MouseMotionListener
y en lugar de implementar los métodos de la interface MouseListener, se implementan solo los métodos necesarios haciendo uso
de la clase abstracta MouseAdapter, métodos a iplementar: mousePressed(), mouseReleased().
import java.awt.*;
import java.applet.*;
import java.awt.event.*;
public class LineaVer2 extends Applet implements MouseMotionListener
{int x1=0, y1=0;
int x2=0, y2=0;
boolean draw;
public void init()
{addMouseListener(new MouseAdapter() // se implementan los métodos de la clase abstracta MouseAdapter
{ public void mousePressed(MouseEvent e)
{x2=e.getX();
y2=e.getY();
draw=true;
}
public void mouseReleased(MouseEvent e)
{draw=false;}
}
);
Maria Eugenia Puga Nathal
Página 15
08/08/2017
Manejo de eventos
addMouseMotionListener(this);
draw=false;
}
//métodos de la interface MouseMotionListener
public void mouseDragged(MouseEvent e)
{x1=e.getX();
y1=e.getY();
repaint();
}
public void mouseMoved(MouseEvent e)
{showStatus("Moviendo mouse en: "+e.getX()+","+e.getY());}
public void paint(Graphics g)
{if (draw) {g.drawLine(x1,y1,x2,y2);}
}
// opcional, ya que es un applet, se pone esto si quieren que se ejecute también como una aplicación.
public static void main(String arg[])
{Frame f=new Frame();
LineaVer2 linea=new LineaVer2();
f.add(linea);
linea.init();
f.setSize(600,600);
f.setVisible(true);
f.addWindowListener(new CerrarVentana());
}
}
Página html para este ejemplo:
<html>
<applet code="LineaVer2.class" width=600 height=600>
</applet>
</html>
Clase Point
Hace referencia a la localización de un punto gráfico (pixel), contiene dos valores de acceso público x e y.
Métodos constructores:
new Point();
new Point(int x, int y);
new Point(new (Point p));
Variables de instancia:
int x;
int y;
Point p=new Point();
p.x
p.y
algunos métodos:
Point punto=new Point();
boolean punto.equals(Point p); // compara dos puntos
punto.move(int x, int y); // mueve el punto a otra posición
Maria Eugenia Puga Nathal
Página 16
08/08/2017
Manejo de eventos
punto.setLocation(Point p);
punto.setLocation(int x, int y); // colocar el punto en otra posición
punto, translate(int dx, int dy); // cambia las coordenadas del punto mediante la adición de dx y dy a sus coordenadas x e y,
// respectivamente.
Clase Dimension
Contienen dos valores de acceso público, width y height
Métodos constructors:
new Dimension();
new Dimension(int width, int height);
new Dimension(Dimension d);
Variables de instancia:
int width;
int height;
algunos métodos:
Dimension dim=new Dimension();
boolean dim.equals(Dimension d);
dim.setSize(Dimension d);
dim.setSize(int width, int height); //ajusta los valores de altura y anchura del objeto a los especificados
Ejemplo de la clase Point
Se crea una clase que hereda todas las características y atributos de la clase Frame, en este ejemplo se hace uso del evento del
ratón “arrastrar ratón (mouseDragged)”, y de la incorporación de una etiqueta (componente) haciendo uso de la clase Label. El
Frame tiene por definición del administrador BorderLayout, el cual divide la ventana en cinco áreas: Norte, Sur, Este, Oeste, y
Centro, por lo que cuando se va a incorporar un componente, administrador o contenedor se le tendrá que indicar en que parte
ubicarlo, para este caso se le indica que la etiqueta la coloque en la parte sur (add(new Label("arrastrar el raton para
dibujar"),BorderLayout.SOUTH);), el manejo del evento del ratón, se programa a través de la clase abstracta
MouseMotionAdapter, la cual solo permite rediseñar los métodos que se utilizarán en la aplicación, a diferencia de que si se
hubiese hecho con la interfaz MouseMotionListener.
// este programa permite dibuja, para ello hay que arrastrar el ratón, una vez que agotamos los
// puntos permitidos, deja de dibujar el raton.
import java.awt.*;
import java.awt.event.*; // importa el paquete para el manejo de eventos
public class Pintar extends Frame
{ int contador=0;
Point [] p=new Point[1000]; // se establece la cantidad maxima de puntos a dibujar
public Pintar() // método constructor, si se tratará de un applet, este seria el método init()
{super ("Pizarra de dibujo electronica"); // llama a la super clase (Frame) y pone titulo al frame
add(new Label("arrastrar el raton para dibujar"),BorderLayout.SOUTH); // incorpora la etiqueta al Frame
addMouseMotionListener( new MouseMotionAdapter() // se programa la captura del evento del ratón
{ public void mouseDragged(MouseEvent e)
//cada vez que se arrastra el raton se va obteniendo la coordenada para despues dibujar ese punto
{ if (contador<p.length)
{ p[contador]=e.getPoint();
contador++;
repaint();
}
}
}
);
Maria Eugenia Puga Nathal
Página 17
08/08/2017
Manejo de eventos
setSize(600,600); // se establece el tamaño del Frame
setVisible(true); // se establece que el Frame sea visible, si se envía false como argumento, no se visualiza el Frame
}
public void paint(Graphics g)
{ super.paint(g); // se llama al metodo paint de la superclase
for(int i=0;i<p.length && p[i]!=null;i++)
{g.fillOval(p[i].x,p[i].y,4,4);}
}
public static void main (String arg[])
{Pintar pizarra=new Pintar();
pizarra.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e){System.exit(0);}});
}
}
Ejemplos de eventos del teclado
El siguiente applet, muestra en la barra de estado, cuando se presiona o se suelta una tecla:
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class teclas1 extends Applet implements KeyListener
{String msg="";
int x=10,y=20;
public void init()
{addKeyListener(this);
requestFocus();
}
public void keyPressed(KeyEvent e)
{showStatus("se presiono una tecla");}
public void keyReleased(KeyEvent e)
{showStatus("se solto una tecla");}
public void keyTyped(KeyEvent e)
{msg+=e.getKeyChar();
repaint();
}
public void paint(Graphics g)
{g.drawString(msg,x,y);}
}
Página html para este ejemplo:
/*
<html>
<applet code="teclas1.class" width=300 height=300>
</applet>
</html>
*/
El siguiente applet presenta un mensaje correspondiente a la tecla presionada
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class teclas2 extends Applet implements KeyListener
{String msg="";
int x=10,y=20;
public void init()
{addKeyListener(this);
Maria Eugenia Puga Nathal
Página 18
08/08/2017
Manejo de eventos
requestFocus();
}
public void keyPressed(KeyEvent e)
{showStatus("se presiono una tecla");
switch(e.getKeyCode())
{case KeyEvent.VK_F1:msg+=" F1 ";break;
case KeyEvent.VK_F3:msg+=" F3 ";break;
case KeyEvent.VK_F5:msg+=" F5 ";break;
case KeyEvent.VK_PAGE_DOWN:msg+=" abajo ";break;
case KeyEvent.VK_PAGE_UP:msg+=" arriba ";break;
case KeyEvent.VK_LEFT:msg+=" flecha izq ";break;
case KeyEvent.VK_RIGHT:msg+=" flecha der ";break;
}
repaint();
}
public void keyReleased(KeyEvent e)
{showStatus("se solto una tecla");}
public void keyTyped(KeyEvent e)
{msg+=e.getKeyChar();
repaint();
}
public void paint(Graphics g)
{g.drawString(msg,x,y);}
}
Página del ejemplo anterior.
/*
<html>
<applet code="teclas2.class" width=300 height=300>
</applet>
</html>
*/
Maria Eugenia Puga Nathal
Página 19
08/08/2017