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 JBuuton 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){……..}
}
No hay comentarios:
Publicar un comentario