EVENTOS
Un evento constituye
un método para que una clase notifique a los usuarios de un objeto que algo
interesante le sucede, como, por ejemplo, que se ha hecho clic en un control
de una interfaz gráfica de usuario. Esta notificación se denomina provocar
un evento, este evento desencadenará una acción.
En este
caso el evento es hacer clic, pero dependiendo de en qué botón hagamos clic la
acción que se desencadena es diferente. No es lo mismo hacer clic en el botón
de grabar de un formulario que hacer clic en el de cerrar. Pero el evento sí
que es el mismo hacer clic.
Para
programar en java eventos nos resultaran necesarios 3 objetos:
1. Que
desencadenante de la acción (hacer clic, cerrar ventana, cargar el programa.. )
OBJETO
EVENTO
2. Quien
desencadena la acción (que botón toco el usuario, que venta cerro, que programa
cerro…)
OBJETO FUENTE
3. Quién
recibe la acción , cuando hagamos clic en el botón X sobre que objeto se
desencadenara la acción(la ventana, el programa, el formulario, la impresora..)
OBJETO LISTENER implementa la interface ActionListener
Ejemplo.
Nosotros tenemos un formulario
con un botón guardar y el usuario lo clica para cerrar el programa.
OBJETO EVENTO =
Hacer clic
OBJETO FUENTE = El
botón rojo, amarillo o azul
OBJETO LISTENER = La
lamina
ACCIÓN = Modificar color de la lámina (setBackground)
Crear un botón (button) ActionListener
Para crear el botón en la lámina
necesitamos la clase JBuuton, creamos un objeto de la clase JButton y con el
método add() lo cargamos en el constructor;
class Lamina6 extends JPanel{
private Image foto;
JButton PrimerBoton= new JButton
("CERRAR");
// constructor donde hacemos
visible el boton
public Lamina6() {
add(PrimerBoton);
}
Ejercicio:
Es la interface que tenemos que
utilizar para realizar acciones de botones, esta interface nos obliga a
implementar el método actionPerformed(ActionEvent e)
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class ddd {
public static void main(String[] args) {
Marco10 mimarco10 = new
Marco10();
mimarco10.setVisible(true);
mimarco10.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco10 extends JFrame{
public Marco10() {
setTitle("ESTE ES NUESTRO MARCO");
setBounds
(700,300,500,300);
Lamina colores = new
Lamina();
add(colores);
}
}
class Lamina extends JPanel implements ActionListener{
JButton botonAzul = new
JButton("Azul");
JButton botonRojo = new
JButton("Rojo");
JButton botonAmarillo = new
JButton("Amarillo");
public Lamina() {
add(botonAzul);
add(botonRojo);
add(botonAmarillo);
botonAzul.addActionListener(this);//el oyente es la lamina (this)
botonRojo.addActionListener(this);
botonAmarillo.addActionListener(this);
}
public void
actionPerformed(ActionEvent e) {
Object FUENTE = e.getSource();
if (FUENTE == botonAzul) {setBackground(Color.blue);}
else if (FUENTE == botonRojo)
{setBackground(Color.RED);}
else if (FUENTE == botonAmarillo)
{setBackground(Color.YELLOW);}
}
}
También
lo podríamos hacer así:
public void actionPerformed(ActionEvent e) {
switch (e.getActionCommand())
{
case "Azul":
setBackground(Color.blue); break;
case "Amarillo": setBackground(Color.yellow); break;
case "Rojo": setBackground(Color.red); break;
default:
break;
}
}
_____________________________________________________________________________
PODRIAMOS
EJECUTAR EL EJERCICIO ANTERIOR UTILIZANDO UNA CLASE INTERNA Y CREANDO OBJETOS
CON LOS COLORES.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class ddd {
public static void main(String[] args) {
Marco10 mimarco10 = new
Marco10();
mimarco10.setVisible(true);
mimarco10.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco10 extends JFrame{
public Marco10() {
setTitle("ESTE ES NUESTRO MARCO");
setBounds
(700,300,500,300);
Lamina colores = new
Lamina();
add(colores);
}
}
class Lamina extends JPanel{
JButton botonAzul = new
JButton("Azul");
JButton botonRojo = new
JButton("Rojo");
JButton botonAmarillo = new
JButton("Amarillo");
public Lamina() {
add(botonAzul);
add(botonRojo);
add(botonAmarillo);
ColorFondo2 auzul = new
ColorFondo2(Color.BLUE);
ColorFondo2 Rojo = new ColorFondo2(Color.red);
ColorFondo2 Amarillo = new
ColorFondo2(Color.YELLOW);
botonAzul.addActionListener(auzul);//el oyente
botonRojo.addActionListener(Rojo);
botonAmarillo.addActionListener(Amarillo);
}
///UTIÑIZAMOS UNA CLASE INTERNA
DENTRO DE LA LAMINA
private class
ColorFondo2 implements ActionListener{
private Color ColorDefondo;
public ColorFondo2 (Color c) {//constructor
ColorDefondo=c;
}
public void
actionPerformed (ActionEvent e) {
setBackground(ColorDefondo);
}
}
}
Eventos de ventanas WindowListener
WindiowListener se utiliza para activar acciones de ventana.
Nuestro oyente serán acciones que realice nuestra venta o Frame (maximizar,
cerrar, mientras se cierra, mientras se queda en segundo plano, restaurar,
minimizar, abrir).
METODOS: La interface WindowListener nos obliga a
implementar los siguiente métodos siempre, los utilicemos o no.
1. public void
windowActivated(WindowEvent e)
{SE
DESEMBOCA AL MAXIMIZAR LA CENTA}
2. public void windowClosed(WindowEvent e) {DESEMBOCA AL CERRAR LA VENTANA}
3. public void windowClosing(WindowEvent e) {SE DESEMBOCA MIENTRAS CERRAMOS LA
VENTANA"}
4. public void windowDeactivated(WindowEvent e) {DESEMBOCA AL DEJAR EN SEGUNDO
PLANO O MINIMIZADA LA VENTANA"}
5. public void windowDeiconified(WindowEvent e) {DESEMBOCA AL RESTAURAR LA VENTANA}
6. public void windowIconified(WindowEvent e) {MINIMIZAR VENTANA}
7. public void windowOpened(WindowEvent e) {DESEMBOCA AL ABRIR LA VENTANA}
En el siguiente ejemplo crearemos
dos marcos situándolos en dos puntos diferentes de la pantalla y utilizaremos
los eventos de pantalla implementado la interface WindowListener, hecho que nos obligara a poner todos sus
métodos.
import javax.swing.*;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
public class frame1
{
public static void main(String[] args) {
Marco MARCO_1 = new
Marco();
Marco MARCO_2 = new
Marco();
MARCO_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MARCO_1.setTitle("MARCO 1");
MARCO_1.setBounds(200,300,500,350);
MARCO_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
MARCO_2.setTitle("MARCO 2");
MARCO_2.setBounds(800,300,500,350);
}
}
class Marco extends JFrame{
public Marco() {
setBounds(300,300,500,350);
setVisible(true);
lamina l = new lamina();
add(l);
//PONEMOS A NUESTRO MARCO A LA
ESPERA DE UNA ACCION DE VENTA
oyente oyenteVentana = new
oyente();
addWindowListener(oyenteVentana);
}
}
class lamina extends JPanel{
public void
paintComponent(Graphics g) {
super.paintComponent(g);
//refundicion de
Graphics2D
Graphics2D g2d = (Graphics2D) g;
Font Letra = new Font("Arial",Font.BOLD,20);
setBackground(Color.darkGray);
g.setFont(Letra);
g.setColor(Color.YELLOW);
g.drawString("TEXTO
1", 100, 100);
}
}
class oyente implements WindowListener{
//TENEMOS QUE IMPLIMENTAR TODOS
LOS MÉTODOS
public void
windowActivated(WindowEvent e) {
System.out.println("SE DESEMBOCA AL MAXIMIZAR LA
CENTA");
}
public void
windowClosed(WindowEvent e) {
System.out.println("SE DESEMBOCA AL CERRAR LA
VENTANA");
}
public void
windowClosing(WindowEvent e) {
System.out.println("SE DESEMBOCA MIENTRAS
CERRAMOS LA VENTANA");
}
public void
windowDeactivated(WindowEvent e) {
System.out.println("DESEMBOCA AL DEJAR EN SEGUNDO
PLANO O MINIMIZADA LA VENTANA");
}
public void
windowDeiconified(WindowEvent e) {
System.out.println("DESEMBOCA AL RESTAURAR LA
VENTANA");
}
public void
windowIconified(WindowEvent e) {//oyente boton minimizar
System.out.println("MINIMIZAR VENTANA");
}
public void
windowOpened(WindowEvent e) {
System.out.println("DESEMBOCA AL ABRIR LA
VENTANA");
}
}
Eventos de ventanas con clases adaptadoras
Normalmente cuando deseamos utilizar un interface
windowlistener nos obliga a tener que implementar los 7 métodos.
1. Public void
windowActivated(WindowEvent e)
{}
2. public void windowClosed(WindowEvent e) {}
3. public void windowClosing(WindowEvent e) {}
4. public void windowDeactivated(WindowEvent e) {}
5. public void windowDeiconified(WindowEvent e) {}
6. public void windowIconified(WindowEvent e) { }
7. public void windowOpened(WindowEvent e) {}
Para evitar esto tenemos las clases adaptadoras,
en nuestro caso utilizaremos la clase WindowAdapter.
La clase WindowAdapter tiene ya implementadas
las interfaces:
WindowFocusListener
WindowListener
WindowStateListener
EentListener
Por lo que si en nuestra clase herea de
WindowAdapter tendremos implementados todos los métodos, evitando así tener que
declararlos todos.
public Marco() {
setBounds(300,300,500,350);
setVisible(true);
lamina l = new lamina();
add(l);
addWindowListner( new oyente());
}
}
class oyente extends
WindowAdapter{………….}
EJERCICIO.
import javax.swing.*;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
public class frame1
{
public static void main(String[] args) {
Marco MARCO_1 = new
Marco();
Marco MARCO_2 = new
Marco();
MARCO_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
MARCO_1.setTitle("MARCO 1");
MARCO_1.setBounds(200,300,500,350);
MARCO_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
MARCO_2.setTitle("MARCO 2");
MARCO_2.setBounds(800,300,500,350);
}
}
class Marco extends JFrame{
public Marco() {
setBounds(300,300,500,350);
setVisible(true);
lamina l = new lamina();
add(l);
//PONEMOS A NUESTRO MARCO A LA
ESPERA DE UNA ACCION DE VENTA
addWindowListener(new oyente());
}
}
class lamina extends JPanel{
public void
paintComponent(Graphics g) {
super.paintComponent(g);
//refundicion de
Graphics2D
Graphics2D g2d = (Graphics2D) g;
Font Letra = new Font("Arial",Font.BOLD,20);
setBackground(Color.darkGray);
g.setFont(Letra);
g.setColor(Color.YELLOW);
g.drawString("TEXTO
1", 100, 100);
}
}
class oyente extends WindowAdapter{ //TENEMOS QUE IMPLIMENTAR TODOS LOS MÉTODOS
public void
windowActivated(WindowEvent e) {
System.out.println("SE DESEMBOCA AL MAXIMIZAR LA
CENTA");
}
public void
windowClosed(WindowEvent e) {
System.out.println("SE DESEMBOCA AL CERRAR LA
VENTANA");
}
public void
windowClosing(WindowEvent e) {
System.out.println("SE DESEMBOCA MIENTRAS
CERRAMOS LA VENTANA");
}
public void
windowDeactivated(WindowEvent e) {
System.out.println("DESEMBOCA AL DEJAR EN SEGUNDO
PLANO O MINIMIZADA LA VENTANA");
}
public void
windowDeiconified(WindowEvent e) {
System.out.println("DESEMBOCA AL RESTAURAR LA
VENTANA");
}
public void
windowIconified(WindowEvent e) {//oyente boton minimizar
System.out.println("MINIMIZAR VENTANA");
}
public void
windowOpened(WindowEvent e) {
System.out.println("DESEMBOCA AL ABRIR LA
VENTANA");
}
}
CONTROLADOR DE ESTADOS DE UNA VENTANA
Existe una interface que actúa
cuando existe una modificación del estado de ventana sea cual sea (aumentar,
minimizar, maximizar, cerrar…). WindowStateListener y recibe por parámetro el
método WindowStateChanged(Windowevent e). Este método actuará cuando exista una
modificación del estado de nuestra ventana.
Windowevent tiene dos métodos:
getNewState(): Obtener nuevo estado.
getOldState():Obtener anterior estado.
En el siguiente ejercicio vamos a
hacer dos marcos, le incluiremos dos botones y un texto, cuando realicemos una
acción de venta (cerrar, abrir, maximizar…) nos saltara un mensaje avisando de
que hemos realizado una modificación en nuestra ventana.
import javax.swing.*;
import java.awt.*;
import
java.awt.event.*;
public class
practica_frame6 {
public static void main (String[] arg) {
Marco_100 Marco_1 = new Marco_100();
Marco_100 Marco_2 = new Marco_100();
Marco_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Marco_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Marco_1.setVisible(true);
Marco_2.setVisible(true);
Marco_1.setBounds(100,300,400,300);
Marco_2.setBounds(500,300,400,300);
}
}
class Marco_100
extends JFrame{
public Marco_100() {
ModificaEstado cambio = new
ModificaEstado();
Lamina10 l1 = new Lamina10();
add(l1);
addWindowStateListener(cambio);
setVisible(true);
}
}
class Lamina10
extends JPanel{
public void paintComponent(Graphics g) {
super.paintComponent(g);
JButton cerrar = new JButton("CERRAR");
JButton open = new JButton("open");
Font Arial = new Font("Arial",Font.BOLD,20);
add(cerrar); add(open);
setBackground(Color.blue);
g.setFont(Arial);
g.setColor(Color.WHITE);
g.drawString("texto
1", 100, 100);
}
}
__________________________________________________________________
///////cuando
hagamos algo con nuestra venta ejecutara esto//////
__________________________________________________________________
class ModificaEstado
implements WindowStateListener {
public void windowStateChanged(WindowEvent e) {
JOptionPane.showMessageDialog(null,"VENTANA MODIFICADA");
}
}
En el siguiente ejercicio crearemos dos
marcos con dos botones, y utilizaremos el método getNewState()
de la interface Windowevent para que nos regrese el estado en que se
encuentra nuestra ventana, este estado nos lo regresa como un int que
introduciremos en un array para que nos regrese un output de texto en el
que nos indicará el estado de la ventana.
En la siguiente tabla os dejo los diferentes
estados:
|
Constant Field
|
Value
|
|
1
|
|
|
0
|
|
|
11
|
|
|
12
|
|
|
1
|
|
|
6
|
|
|
2
|
|
|
4
|
|
|
13
|
|
|
8
|
|
|
7
|
|
|
0
|
|
|
6
|
|
|
9
|
|
|
5
|
|
|
4
|
|
|
2
|
|
|
10
|
|
|
3
|
Ejercicio 2
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class practica_frame6 {
public static void main (String[] arg) {
Marco_100
Marco_1 = new
Marco_100();
Marco_100
Marco_2 = new
Marco_100();
Marco_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Marco_2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
Marco_1.setVisible(true);
Marco_2.setVisible(true);
Marco_1.setBounds(100,300,400,300);
Marco_2.setBounds(500,300,400,300);
}
}
class Marco_100 extends JFrame{
public Marco_100() {
ModificaEstado
cambio = new
ModificaEstado();
Lamina1000 l1 = new Lamina1000();
add(l1);
addWindowStateListener(cambio);
setVisible(true);
}
}
class Lamina1000 extends JPanel{
public void paintComponent(Graphics g) {
super.paintComponent(g);
JButton
cerrar = new
JButton("CERRAR");
JButton
open = new
JButton("open");
Font Arial = new Font("Arial",Font.BOLD,20);
add(cerrar); add(open);
setBackground(Color.blue);
g.setFont(Arial);
g.setColor(Color.WHITE);
g.drawString("texto 1", 100, 100);
}
}
class ModificaEstado implements WindowStateListener {
public void windowStateChanged(WindowEvent e) {
int tipoVentana = e.getNewState();//nos regresa un numero
String
[] estado = {
"Ventana en estado DEFAULT_CURSOR",
"Ventana en estado espera",
"Ventana en estado Maximiza horizontal",
"Ventana en estado Minimiza",
"Ventana en estado SW_REDIMENSIONAR_CURSOR", "Ventana en estado SE_REDIMENSIONAR_CURSOR",
"Ventana en estado S_REDIMENSIONAR_CURSOR",
"Ventana en estado NORMAL",
"Ventana en estado N_REDIMENSIONAR_CURSOR",
"Ventana en estado W_REDIMENSIONAR_CURSOR",
"Ventana en estado HAND_CURSOR",
"Ventana en estado MOVE_CURSOR"};
JOptionPane.showMessageDialog(null,estado[tipoVentana ]);
}
}
Si nosotros necesitamos usar estos estados en un if
seguramente no nos acordaremos de los números. Podemos hacer uso de
Frame.Estado.
Ejem
class ModificaEstados implements WindowStateListener {
public void windowStateChanged(WindowEvent e) {
if(e.getNewState()==
Frame.MAXIMIZED_BOTH) {
JOptionPane.showMessageDialog(null,"mawimizada");
}
if(e.getNewState()==Frame.NORMAL) {
JOptionPane.showMessageDialog(null,"ventana normal");
}
Eventos de teclado con interface KeyListner
Un evento de teclado se desencadena cuando
nuestro usuario ejerce sobre el teclado una determinada combinación de teclas.
Cuando estáis en Works y tocáis Control+n el texto se pone en negrita, eso es
un evento de teclado.
Para programar eventos de teclado necesitaremos la interface
KeyListner, esto nos obliga a programar tres métodos:
·
KeyPressed
(KeyEvent e): Tecla presionada, se puede utilizar para combinaciones le
podemos decir que si mantiene pulsada una tecla y después toca otra, os suena
de algo esto (Ctrl+t , Ctrl+x, Ctrl+z…) pues si introducimos un if lo
tenemos. .
·
KeyReleased
(KeyEvent e): Tecla liberada, cuando soltamos la tecla.
·
KeyTyped
(KeyEvent e): Clave mecanografiada, cuando hemos presionado la tecla y la
hemos soltado.
Si no queremos crear todos los métodos porque solo vamos a
utilizar uno de ellos tenemos la clase adaptadora KeyAdapter.
La case keyListener pasa por parámetros la clase KeyEvent por lo que tendremos a nuestra
disposición todos los métodos de ella:
·
getKeyChar():
Nos regresa la tecla pulsada.
·
getKeyChar():
Nos regresa el código que representa para java la tecla pulsada
Podemos crear la clase que implementa e implementar la
interface KeyListener, hecho que nos obligará a crear los tres métodos.
En el siguiente ejemplo java escribirá en la pantalla de
inmediato de nuestro equipo cada tecla que nosotros vallamos pulsando.
class EscuchaTeclado implements KeyListener{//oyente
public void keyPressed(KeyEvent e) {
int codice=e.getKeyChar();
System.out.print(e);
}
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) {}
}
Y luego llamarla
desde el constructor del frame:
class Marco_1000 extends JFrame{
public Marco_1000() {
EscuchaTeclado tecla = new EscuchaTeclado();
addKeyListener(tecla);
ModificaEstados
cambio = new
ModificaEstados();
Lamina1000 l1 = new Lamina1000();
add(l1);
addWindowStateListener(cambio);
setVisible(true);
}
}
Eventos de ratón MouseListener
La interface MouseListener implementa 5 métodos, por lo que
cuando la utilicemos tendremos que crearlos o utilizar una clase adaptadora que
los tiene implementados, en nuestro caso sería MouseAdapter.
Métodos de MouseListener:
·
mouseCliked
(mouseEvent e): El usuario ya ha presionado y soltado el botón.
·
mousePreseed
(mouseEvent e): El botón del ratón está siendo presionado
·
mouseReleased
(mouseEvent e): El botón del ratón está regresando a su lugar después de
haber sido presionado (el usuario retira el dedo del botón).
·
mouseEntered
(mouseEvent e): Cuando el puntero del ratón entra en una zona determinada
de la pantalla
·
mouseExited
(mouseEvent e): Cuando el puntero del ratón sale en una zona determinada de
la pantalla
MousListener en sus
métodos para por parámetros mousEvent por lo que tendremos a nuestra
disposición los métodos de esta clase.
Métodos MouseEvent:
·
getX():posición X del ratón en pantalla en un
momento determinado
·
getY():posición Y del ratón en pantalla en un
momento determinado
·
gerModifiersEx(): nos indica si el usuario ha
tocado el botón derecho, izquierdo o l
rueda del ratón.
·
getClickCount(): Cuenta el número de clics que
ha hecho el usuario.
1º. Creamos una clase que implementa la interface
MouseListener
class raton implements MouseListener {// oyente raton
public void mouseClicked(MouseEvent e) {
JOptionPane.showMessageDialog(null,"HAS HECHO CLICK CON EL RATON EN EL PUNTO X; "+e.getX()+ ", Y: "+e.getY()+ " de la lamina");
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
}
2º. Ahora la
cargamos en el constructor del frame.
class Marco_1000 extends JFrame{
public Marco_1000() {
//eventos
raton
raton
Perez = new raton();
addMouseListener(Perez);
// eventos teclado
EscuchaTeclado
tecla = new
EscuchaTeclado();
addKeyListener(tecla);
// eventos de venta
(para botones)
ModificaEstados
cambio = new
ModificaEstados();
addWindowStateListener(cambio);
//lamina del frame
Lamina1000 l1 = new Lamina1000();
add(l1);
setVisible(true);
}
Ejercicio: ahora
probemos todos los métodos
class raton implements MouseListener {// oyente raton
public void
mouseClicked(MouseEvent e) {
System.out.println("HAS HECHO CLICK CON EL RATON EN EL
PUNTO X; "+e.getX()+ ", Y: "+e.getY()+ " de la lamina");
System.out.println(e.getClickCount());
}
public void
mouseEntered(MouseEvent e) {
System.out.println("x: " +e.getX()+ " Y:"+e.getY());
}
public void
mouseExited(MouseEvent e) {}
public void
mousePressed(MouseEvent e) {
String [] Qboton = new
String[3];
Qboton[0]="BOTON DERECHO DEL RATON";
Qboton[1]="BONTON IZQUIERDO DEL RATON";
Qboton[2]="RUEDA DEL RATON";
if (e.getModifiersEx()
== 4096) {
System.out.println(Qboton[0]);
} else if (e.getModifiersEx() == 1024) {
System.out.println(Qboton[1]);
} else if(e.getModifiersEx()==2048) {
System.out.println(Qboton[2]);
}
}
El if
anterior también lo podemos hacer así:
class raton implements MouseListener {// oyente raton
public void
mouseClicked(MouseEvent e) {
System.out.println("HAS HECHO CLICK CON EL RATON
EN EL PUNTO X; "+e.getX()+ ",
Y: "+e.getY()+ "
de la lamina");
System.out.println(e.getClickCount());
}
public void
mouseEntered(MouseEvent e) {
System.out.println("x: " +e.getX()+ " Y:"+e.getY());
}
public void
mouseExited(MouseEvent e) {}
public void
mousePressed(MouseEvent e) {
if (e.getModifiersEx()
== MouseEvent.BUTTON2_DOWN_MASK ) {
System.out.println("has `pulsado el boton
izquierdo");
}else if (e.getModifiersEx() == MouseEvent.BUTTON1_DOWN_MASK) {
System.out.println("has pulsado la rueda del
raton");
}else if(e.getModifiersEx()==MouseEvent.BUTTON3_DOWN_MASK) {
System.out.println("has pulsado el boton
derecho");
}
}
public void
mouseReleased(MouseEvent e) {}
}
Eventos de ratón MouseMotionListener
Controla si estamos moviendo o
arrastrando el ratón implementaremos esta interface para controlarlos, se
compone de dos métodos.
·
mouseDragged (MouseEvent e) : Se invoca cuando
se desplaza el ratón con el botón pulsado
·
mouseMoved (MouseEvent e) : Se invoca cuando
movemos el ratón sin pulsar el botón.
Creamos la
clase:
class raton2 implements MouseMotionListener{
public void mouseDragged(MouseEvent e) {
System.out.println("desplazas el ratón con el
botón pulsado");
}
public void mouseMoved(MouseEvent e) {
System.out.println("desplazas el ratón sin
pulsar el botón");
}
Ahora la
cargamos en el frame:
class Marco_1000 extends JFrame{
public Marco_1000() {
//eventos raton
raton Perez = new
raton();
addMouseListener(Perez);
//eventos desplazamiento
raton
raton2 desplazaRaton = new raton2();
addMouseMotionListener(desplazaRaton);
// eventos teclado
EscuchaTeclado tecla = new
EscuchaTeclado();
addKeyListener(tecla);
// eventos de venta
(para botones)
ModificaEstados cambio = new
ModificaEstados();
addWindowStateListener(cambio);
//lamina del frame
Lamina1000 l1 = new Lamina1000();
add(l1);
setVisible(true);
}
Podemos implementar todas las interfaces en una sola clase,
así será más rápido y limpio, evitando cargar clase por clase, todas irán en
una única.
class
ModificaEstados implements WindowStateListener,KeyListener,MouseListener,MouseMotionListener{
public void mouseDragged(MouseEvent e) {….}
public void mouseMoved(MouseEvent e) {……}
public void mouseClicked(MouseEvent e) {……..}
public void mouseEntered(MouseEvent e) {………}
public void mouseExited(MouseEvent e) {……….}
public void mousePressed(MouseEvent e) {……….}
public void mouseReleased(MouseEvent e) {……….}
public void keyPressed(KeyEvent e) {………..}
public void keyReleased(KeyEvent e) {……….}
public void keyTyped(KeyEvent e) {……..}
public void windowStateChanged(WindowEvent arg0){……..}
}
Eventos de foco en componentes FocusListener
Un evento de foco es aquel que se desemboca cuando tenemos
seleccionado un determinado espacio de la interface, podemos tener un botón
seleccionado, un marco, un archivo. Supongo que alguna vez habéis rellenado un
formulario en una web, cuando cambias de casilla estas poniendo el foco en la
siguiente casilla.
En este caso vamos a ver cómo hacerlo dentro de un
componente.
Para
ello utilizaremos la interface FocusListener, por lo que estaremos obligados a
implementar 2 métodos:
·
focusGained
(FocusEvent e): el elemento adquiere el foco.
·
focusLost
(FocusEvent e): el elemento pierde el foco.
En
caso de no desear implementar los dos disponemos de la clase adaptadora
FocusAdapter.
0.
Necesitaremos dos textfiled , las variables se declaran dentro de
la lámina porque serán internas y de uso interno solo en la lamina
class A_lamina extends JPanel{
public void
paintComponent(Graphics g){//constructor
super.paintComponent(g);
setBackground(Color.DARK_GRAY);
setLayout(null); //establecer diseño por defecto no
cuadro1=new
JTextField();
cuadro2=new
JTextField();
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20);
add(cuadro1);
add(cuadro2);
}
JTextField cuadro1,cuadro2;
}
1.
Ahora generamos una clase interna con el
oyente y ponemos y ponemos el cuadro una como desencadenante.
class A_lamina extends JPanel{
public void paintComponent(Graphics g){//constructor
super.paintComponent(g);
setBackground(Color.DARK_GRAY);
setLayout(null); //establecer diseño por defecto
no
cuadro1=new
JTextField();
cuadro2=new
JTextField();
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20);
add(cuadro1);
add(cuadro2);
cuadro1.addFocusListener(new escucha());
}
JTextField
cuadro1,cuadro2;
private Image foto;
private class escucha
implements
FocusListener{
public void
focusGained(FocusEvent e) {System.out.println("estas
dentro del cuadro 1");}
public void
focusLost(FocusEvent e) {System.out.println("estas fuera del cuadro
1");}
} }
En la siguiente práctica
realizaremos un marco al que le introduciremos una lámina con una foto de fondo
y en la que pondremos dos cuadros de texto. Para posteriormente generar los
eventos de foco, ratón, teclado
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.File;
import java.io.IOException;
public class
Practica_JText {
public static void main (String[] arg) {
A_marco1 cuadro = new
A_marco1();
cuadro.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class A_marco1 extends JFrame{
public A_marco1() {
setVisible(true);
setBounds(150,
150, 500, 300);
add(new A_lamina());
addWindowListener(new escucha2());
addWindowStateListener(new escucha2());
addKeyListener(new escucha2());
addMouseListener(new escucha2());
}
}
class A_lamina extends JPanel{
public void
paintComponent(Graphics g){//constructor
super.paintComponent(g);
try { //tratamineto de excepciones, haz esto
y si no catch
foto = ImageIO.read(new File("C:\\Users\\dagip\\Desktop\\BOGEER\\imagenes\\JAVA2.jpg"));//ruta relativa
} catch(IOException e) {
JOptionPane.showConfirmDialog(null, "no esta la foto");
}
//escribimos la foto
en nuestra lamina
g.drawImage(foto, 0, 0, null);
setBackground(Color.DARK_GRAY);
setLayout(null); //establecer diseño por defecto no
cuadro1=new
JTextField();
cuadro2=new
JTextField();
cuadro1.setBounds(100,50,150,20);
cuadro2.setBounds(100,90,150,20);
add(cuadro1);
add(cuadro2);
cuadro1.addFocusListener(new escucha());
}
JTextField cuadro1,cuadro2;
private Image foto;
private class escucha
implements FocusListener{
public void focusGained(FocusEvent e) {
System.out.println("estas dentro del cuadro
1");
}
public void
focusLost(FocusEvent e) {S
ystem.out.println("estas fuera del cuadro
1");
}
}
}
class escucha2 implements
WindowListener,WindowStateListener,MouseListener,ActionListener,KeyListener{
public void
windowStateChanged(WindowEvent e) {}
public void
windowActivated(WindowEvent e) {}
public void
windowClosed(WindowEvent e) {}
public void
windowClosing(WindowEvent e) {}
public void
windowDeactivated(WindowEvent e) {}
public void
windowDeiconified(WindowEvent e) {}
public void
windowIconified(WindowEvent e) {}
public void
windowOpened(WindowEvent e) {}
public void
keyPressed(KeyEvent e) {}
public void
keyReleased(KeyEvent e) {}
public void
keyTyped(KeyEvent e) {}
public void
actionPerformed(ActionEvent e) {}
public void
mouseClicked(MouseEvent e) {}
public void
mouseEntered(MouseEvent e) {}
public void
mouseExited(MouseEvent e) {}
public void
mousePressed(MouseEvent e) {}
public void
mouseReleased(MouseEvent e) {}
}
Ejercicio 2. Ahora generamos otro marco con dos botones y dos
cuadros de texto, y cuando el usuario cambie el foco de un cuadro de texto al
otro nos confirmará si el correo es correcto.
import java.awt.*;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.io.*;
import javax.imageio.ImageIO;
import javax.swing.*;
public class
Practica27_text {
public static void main (String[] arg) {
//cargar el frame
Marco_1111 x =new Marco_1111();
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco_1111 extends JFrame{
public Marco_1111() {
setVisible(true);
setBounds(150,150,800,390);
add(new Lamina_1111());
}
}
class Lamina_1111 extends JPanel{
public
void paintComponent(Graphics g) {
super.paintComponent(g);
//cargar los botones
en el frame
JButton Boton1=new JButton
("cerrar");
JButton Boton2=new JButton
("Abrir");
add(Boton1); add(Boton2);
Boton1.setBackground(Color.GREEN);
Boton1.setBounds(600, 20, 80, 30);
Boton2.setBackground(Color.GREEN);
Boton2.setBounds(600, 55, 80, 30);
// colgar imagen, para
lo que necesitamos un tratamiento de excepciones
try { Foto1=ImageIO.read(new File("C:\\Users\\dagip\\Desktop\\BOGEER\\imagenes\\JAVA2.jpg"));
} catch (IOException e) {
JOptionPane.showConfirmDialog(null, "la foto no esta en la ruta");
}
g.drawImage(Foto1,0,0,null);
c_t1= new JTextField(); c_t2= new JTextField();
c_t1.setBounds(50,50,250,40); c_t2.setBounds(50,100,250,40);
add(c_t1); add(c_t2);
c_t1.addFocusListener(new
EventosDEfoco());
}
JTextField c_t1,c_t2;
Image Foto1;
private class
EventosDEfoco implements FocusListener{
public void
focusGained(FocusEvent e) {}
public void
focusLost(FocusEvent e) {
//para capturar el texto
del cuadro getText()
String Correo = c_t1.getText();
boolean validador_arroba = false;
boolean validador_punto = false;
//ahora vamos a comprobar
si el correo introducido es correcto
for (int i=0;i<Correo.length();i++) {
//recordar que cuando
buscamos una letra serán comillas simples
if (Correo.charAt(i) == '@') {validador_arroba =true;}
if(Correo.charAt(i) == '.') {validador_punto = true;}
}
if(validador_punto==false && validador_arroba==false) {
String remplazar=JOptionPane.showInputDialog(null, "le falta un punto en su correo", "ejemplo@eeee.es");
c_t1.setText(remplazar); }
else if (validador_arroba==false
&& validador_punto == true) {
JOptionPane.showMessageDialog(null, "repasa si has puesto el @");
}
else if (validador_punto==false
&& validador_arroba == true) {
JOptionPane.showMessageDialog(null, "repasa si has puesto el punto");
}
}
}
}
Eventos de foco en marco windowFocusListener
Una interface gráfica puede estar compuesta por varias ventanas,
en este caso puede suceder que una de las ventanas pierda o gane el foco y se
tenga que desencadenar una acción cuando esto suceda. Para esto tenemos
windowFocusListener compuesta por dos métodos.
·
windowLostFocus(WindowEvent
e) para cuando perdemos el foco de la venta.
·
WindowGainedFocus(WindowEvent
e) para cando ganamos el foca en la venta.
Ejm. En el
siguiente ejemplo cargaremos dos macos cuando seleccionemos uno de ellos saldrá
un mensaje en el titulo, y cuando seleccionemos el otro desaparece el mensaje
del primero y aparece en el segundo.
import
java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;
import javax.swing.JFrame;
public class Practica28_
extends JFrame implements
WindowFocusListener{
public static void main(String[] args) {
Practica28_ dd = new Practica28_();
dd.inicar();
}
public void
inicar() {
marco1 = new
Practica28_ (); marco2= new Practica28_();
marco1.setVisible(true); marco2.setVisible(true);
marco1.setBounds(100,200,300,300); marco2.setBounds(400,200,350,350);
marco1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
marco2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//el oyente esta en
nuestra clase por eso penemos this
ventana
marco1.addWindowFocusListener(this); marco2.addWindowFocusListener(this);
}
public void
windowGainedFocus(WindowEvent e) {
if(e.getSource()==marco1) {
marco1.setTitle("TINES EL FOCO!!!!!!!!!");
marco2.setTitle("");
}if (e.getSource()==marco2) {
marco1.setTitle("");
marco2.setTitle("TINES EL FOCO!!!!!!!!!");
}
}
public void
windowLostFocus(WindowEvent e) {}
Practica28_ marco1;
Practica28_ marco2;
}
UTILIZAR VARIAS FUENTES DE EVENTOS
Imaginemos se desencadene una
acción cuando el usuario toco un botón del marco, que esa misma acción se haga
cuando el usuario accione un consunto de teclas
y además que esa misma acción se desencadene cuando haga doble click con
el ratón.
Fuentes:
·
Ratón
·
Botón de marco
·
Combinación teclado
Pero todas desencadenan la misma
acción sobre un oyente.
Para esto utilizaremos la
interface Action que hereda de
ActionPerformed (ActionEvent E) por lo que dispone de todos sus métodos he
implementa propios que nos obliga a
implementas al tratarse de una interface:
actionPerformed(ActionEvent arg0) {}
·
addPropertyChangeListener(PropertyChangeListener arg0) {}
·
Escucha de cambio de propiedad, nos
permitirá agregar una propiedad al objeto oyente.
Ejm. Seleccionar un texto
Object getValue(String arg0) {return null;}
·
Obtener valor. Nos permite obtener la
clave previamente almacenada con putValue
Es un método getter tal y como puede ver
por el return.
isEnabled() {return false;}
·
¿Está habilitado?
Nos devuelve si está activado o no el objeto
fuente de evento. Es un método getter tal y como puede ver por el return.
putValue(String arg0, Object arg1){}
·
Poner valor. Almacena
parejas de clave y de valor.
removePropertyChangeListener(PropertyChangeListener
arg0){}
·
Eliminar el cambio
de oyente. Elimina la propiedad del objeto oyente.
·
Ejm. Dejar de seleccionar un texto
seleccionar un texto
etEnabled(boolean
arg0){}
·
¿Establece habilitado? Verdadero/falso.
Activa o desactiva un objeto fuente de
evento.
En caso de no querer utilizarlas
todas podemos heredar de la clase AbstractAction
y sobrescribir el que necesitemos.
ASIGNAR
ACCIONES AL TECLADO
1.
Crear un
mapa de entrada: La acción siempre se realizara sobre el objeto que tiene
el foco y crear el mapa de entrada es indicar a nuestro programa que objeto
tiene el foco. Utilizaremos las clase InputMap
y JComponent
2.
Crear
combinación de teclas: decirle a nuestro programa que combinación de teclas
declaramos Ctrl+R. Utilizaremeos
la clase KeyStroke
3. Asignar Combinaciones de teclas a objetos: Crear
un objeto para cada una de las asignaciones de teclas. Utilizaremos la clase InputMap.
4. Asignar objetos a acción: Decirle a los
objetos que representan las combinaciones de teclado a los objetos de acciones.
Utilizaremos la clase ActionMap.
Ejercicio. En el siguiente ejercicio crearemos una lámina con fondo
negro un texto en blanco con letra Arial black, tres botones (verde,rojo,azul)
y posterior mente vamos a generar dos fuentes para los eventos. Por una los
botones cambiaran los colores del fondo de la página y por otra existirán unas
teclas de acceso rápido que modificaran el color de la lámina:
Ctrl+R (rojo) Ctrl+V
(verde) Ctrl+A (Azul)
import java.awt.*;
import java.awt.event.ActionEvent;
import javax.swing.*;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
public class Practica29_eventos {
public static void main(String[] args) {
Marco123
Lamina123455888 = new
Marco123();
Lamina123455888.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco123 extends JFrame{
public
Marco123() {
add(new
Lamina123());
setBounds(100,150,500,300);
setVisible(true);
}
}
class Lamina123 extends JPanel{ //creamos la
lamina como inner class.
public Lamina123 () {
//damos color inicial
a la lamamina
setBackground(Color.gray);
//redimensionamos las
fotos en caso de que no sean del
tamaño adecuado para que entren en el
boton
ImageIcon Escala_verde= new ImageIcon("C:\\Users\\ruta\\src/puntoVerde.gif");
Image Escala_verde2 = Escala_verde.getImage().getScaledInstance(10,
10, Image.SCALE_SMOOTH);
ImageIcon Escala_Rojo= new ImageIcon("C:\\Users\\RUTA\\src/puntoRojo.gif");
Image Escala_Rojo2 = Escala_Rojo.getImage().getScaledInstance(10,
10, Image.SCALE_SMOOTH);
ImageIcon Escala_Azul= new ImageIcon("C:\\ruta\\src/puntoAzul.gif");
Image Escala_Azul2 = Escala_Azul.getImage().getScaledInstance(10,
10, Image.SCALE_SMOOTH);
//constres objetos de
la clase Cambio color bajo creada
CambioColor oyente_Verde = new CambioColor("Verde",new
ImageIcon(Escala_verde2),Color.GREEN);
CambioColor oyente_Rojo = new CambioColor("Rojo",new ImageIcon(Escala_Rojo2),Color.RED);
CambioColor oyente_Azul = new CambioColor("Azul",new ImageIcon(Escala_Azul2),
Color.BLUE);
//creamos los
tres botones utilizando los objetos de
la clase CambioColor
add(new JButton(oyente_Verde));
add(new JButton(oyente_Rojo));
add(new JButton(oyente_Azul));
/*1. Crear
un mapa de entrada:
La acción siempre se realizara sobre
el objeto que tiene el foco y crear el mapa
de entrada es indicar a nuestro programa
que objeto
tiene el foco. Utilizaremos las clase
InputMap y mponent, le decimos que tiene que actuar sobre
un objeto que esta en la lámina,
por eso le indicamos ""cuando está enfocado
en la ventana"" when_in_Focused_Window */
InputMap Crear_mapaEntrada = getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
/*2. Crear
combinación de teclas: decirle a nuestro programa
que combinación
* de
teclas declaramos Ctrl+R. Utilizaremeos la clase
KeyStroke*/
KeyStroke
Ctrl_Verde = KeyStroke.getKeyStroke("ctrl V");
KeyStroke
Ctrl_Rojo = KeyStroke.getKeyStroke("ctrl R");
KeyStroke
Ctrl_Azul = KeyStroke.getKeyStroke("ctrl A");
/*3. Asignar Combinaciones de
teclas a objetos: Crear un objeto para
cada
* una
de las asignaciones de teclas. Utilizaremos
la clase InputMap.*/
Crear_mapaEntrada.put(Ctrl_Verde, "F_Verde");
Crear_mapaEntrada.put(Ctrl_Rojo, "F_Rojo");
Crear_mapaEntrada.put(Ctrl_Azul, "F_Azul");
/*4.Asignar
objetos a acción: Decirle a los objetos que
representan las combinaciones
de teclado a los objetos de acciones.
Utilizaremos la clase
ActionMap.*/
ActionMap
mapa = getActionMap();
mapa.put("F_Verde", oyente_Verde);
mapa.put("F_Rojo", oyente_Rojo);
mapa.put("F_Azul", oyente_Azul);
}
public void paintComponent (Graphics g) {
super.paintComponent(g);
//ACCEDEMOS A GRAPHICS2D PARA
HACER UN PUNTERO DE FUENTES
Graphics2D
g22 = (Graphics2D)g;
g22.setFont (new Font("Arial black", Font.BOLD,50));
g22.setColor(Color.BLACK);
//Escribimos el texto
g.drawString("TEXTO 1", 100,130);
}
private class CambioColor extends
AbstractAction{
public CambioColor (String nombre, ImageIcon icono,Color color_boton) {
//Con putValue damos
los valores
putValue(Action.NAME, nombre);
putValue(Action.SMALL_ICON,icono);
putValue(Action.SHORT_DESCRIPTION,"DA COLOR "+ nombre + " A LAMINA");
putValue("COLOR_fONDO", color_boton);
}
public void actionPerformed(ActionEvent e) {
//damos la claves
a los colores con los botones
Color
c = (Color)getValue("COLOR_fONDO");
setBackground(c);
}
}
}
Múltiples fuentes para un solo oyente
Hasta ahora hemos
visto como generar un solo oyente pero múltiples fuentes, imaginemos que
deseamos que un solo oyente tenga varias fuentes.
Ejemplo Realizar un marco con dos botones uno de ellos
abrirá una nueva ventana cada vez que le hagamos click mientras que el segundo
cerrará todas las ventanas abiertas (diferentes oyentes).
Una fuente: El botón de
cerrar
Diferentes oyentes:
Todas las ventanas.
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
public class
Practica30 {
public static void main (String[] args) {
Marco xxx = new Marco();
xxx.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class Marco extends JFrame{
public
Marco() {
add(new Lamina());
setBounds(800,50,500,300);
setVisible(true);
}
}
class Lamina extends JPanel{
public Lamina() {
setBackground(Color.gray);
//creamos los botones
JButton Abrir;
add( Abrir = new
JButton("Abrir"));
add(boton_cerrar = new
JButton("Cerrar
todo"));
//le decimos que
cundo se pulse el botón abrir
//llame a actionlistener
en la clase oyente_ventan
Abrir.addActionListener(new oyente_ventana());
}
JButton boton_cerrar;
//CREAMOS UNA CLASE INTERNA
IMPLEMENTANDO ACTIONLISTENER PARA ABRIR LAS
//LAS NUEVAS VENTANAS
private class
oyente_ventana implements ActionListener{
public void
actionPerformed(ActionEvent g) {
Nuevo nuevos_marco = new Nuevo(boton_cerrar);
nuevos_marco.setVisible(true);
}
}
public void
paintComponent(Graphics g){
super.paintComponent(g);
Graphics2D g22 = (Graphics2D)g;
g22.setFont(new Font("Arial Black",Font.BOLD,50));
g.setColor(Color.BLUE);
g.drawString("TEXTO", 150, 175);
}
}
//CREAMOS UN FRAME PARA LAS NUEVAS VENTANAS
class Nuevo extends JFrame{
public Nuevo(JButton llamar_boton_cierre) {
SUMA_VENTAN++;
desplaza_ventan+=20;
setTitle("VENTANA " +SUMA_VENTAN);
//Para evitar que
se superpongan las ventans lo
//sumamos el eje X y
el eje Y desplaza_ventan
setBounds(30+desplaza_ventan,30+desplaza_ventan,300,150);
//llamos al boton
del constructor de la clase Lamina
//que hemos pasado
por parametros
llamar_boton_cierre.addActionListener(new Cerrador());
}
// encapsulamos dos
variable para utilizarlas solo en este constructor
private static int SUMA_VENTAN =0;private static int desplaza_ventan=0;
//crearemos una clase
interna para cerar los marcos
private class
Cerrador implements ActionListener{
public void
actionPerformed(ActionEvent e) {
//ultilizamos el metodo
dispose() de Jframe para
//cerrar todos los
objetos y liberar recursos
dispose();
}
}
}
No hay comentarios:
Publicar un comentario