eventos y applets

TOPICOS AVANZADOS DE PROGRAMACIONMATERIA:

DE LA CRUZ CRUZ MARICELAFLORENTINO RAMOS MARTHA LETICIA

GONZALES HERNANDEZ FRANCISCO AGUSTINHERNANDEZ HERNANDEZ MARIA DE LOS ANGELES

MEZA CONTRERAS DIANA SARAHIRIVERA RAMOS MILDRED SARID

INTEGRANTES:

UNIDAD 1TRABAJO:

LIC. IRMA ASCENCIO LLADOMAESTRO:

ING. EN SISTEMAS COMPUTACIONALESCARRERA:

4°SEMESTRE:

CERRO AZUL, VER; FEBRERO DE 2012

TOPICOS AVANZADOS DE PROGRAMACION

EQUIPO 5 UNIDAD 1 Página 1

INSTITUTO TECNOLOGICO DE CERRO AZUL


INDICE

EVENTOS……………………………………………………………………………3

TIPOS DE EVENTOS……………………………………………………………….3

GENERACION Y PROPAGACION DE EVENTOS………………………………4

METODOS DE CONTROL DE EVENTOS…………………………………...……5

APPLETS…………………………………………………………………………….9

PROGRAMAS……………………………………………………………………....11

BIBLIOGRAFIA…………………………………………………………………….32



UNIDAD 1.- EVENTOS

Un evento es una acción iniciada por el usuario. Cada vez que se produce un evento, se crea un objeto.La clase padre de los eventos es: java.awt.Event.La clase Event es el jugador principal en el juego de los eventos. Intenta capturar las caracteristicas principales o fundamentales de todos los eventos que genera el usuario.

TIPOS DE EVENTOS

Los eventos se dividen en dos clases: de bajo nivel o de componente, y de altonivel o semánticos.

Eventos de bajo nivel o de componenteSon aquellos que representan una entrada sobre un componente visual de unsistema de ventanas en la pantalla. Hacer click con el ratón, oprimir una tecla.

La clase Component del AWT, define los métodos de procesamiento y registrode escucha para eventos a nivel de componente. Por ejemplo el métodoaddMouseListener(), que agrega un escucha para recibir eventos del ratónen un componente,o addKeyListener() para agregar un escucha que recibaeventos del teclado en un componente.

Todos los eventos a nivel de componente son subclases de java.awt.event, talescomo:

ComponentEvent: Evento de bajo nivel que indica que un componente se

ha movido, cambiado su tamaño, o cambiada su visibilidad.

FocusEvent: Evento generado por un componente, que indica que elcomponente ha ganado o perdido su enfoque en el teclado.

InputEvent: es la clase raiz para todos los eventos de entrada a nivel decomponente. Los eventos de entrada son despachados a los escuchas antesque que sean procesados normalmente por las fuentes donde ellos segeneraron.

KeyEvent: indica que se ha presionado una tecla en un componente. Este

evento se genera por un objeto componente, por ejemplo un campo de texto,cuando una tecla es presionada, suelta, o se genera un carácter con ella



presionándola y soltandola.

MouseEvent: Evento que indica que ha sucedido una accion con el ratón

sobre algún componente. Estas acciones pueden ser:Eventos simples del ratón: un boton presionado, suelto o liberado,presionado y liberado, el cursor del ratón entra o sale de un componente.Eventos de movimiento del ratón: el ratón se ha movido, el ratón se hamovido con un boton presionado (dragged).

ContainerEvent: Evento que indica que el contenido de un contenedor ha

cambiado en virtud de haberse agregado o suprimido un componente.

WindowEvent: Evento que indica que una ventana ha cambiado su estado,

por ejemplo cuando se abre, se cierra, se activa o desactiva, cuando seminimiza (iconified) o restaura (deconified).

Eventos semánticos o de alto nivelAquellos que representan la función o significado de más alto nivel de unEvento, por ejemplo hacer doble clic con el ratón en una línea de texto. Lossiguientes son algunos eventos semánticos:

ActionEvent: evento que indica que ha sucedido una acción definida en un

componente, por ejemplo presionar un botón para que realice una funcióndefinida para ese componente.

AdjustmentEvent: este evento se genera cuando se ajusta el valor de de un

objeto ajustable.La gestión de eventos : Tipos de eventos 10 - 16

ItemEvent:Este evento indica que un elemento ha sido seleccionado odeseleccionado, cambiando su estado, por ejemplo en una lista al seleccionaruno de sus elementos.

TextEvent: evento que indica que un objeto texto por ejemplo

TextComponent ha cambiado su texto.

GENERACIÓN Y PROPAGACIÓN DE EVENTOS

Tomemos el applet, EventosPro.java. Consta de dos instancias de la clase Button, embebidas dentro de una instancia de la clasePanel. Esta instancia está a su vez embebida dentro de otra instancia de la clasePanel. Esta última



instancia de la clase Panel está situada junto a una instancia de la clase TextArea, y ambas están embebidas dentro de una instancia de la claseApplet. Cuando un usuario interactúa con el applet, el sistema Java crea una instancia de la clase Event y rellena sus datos miembro con la información necesaria para describir la acción. Es en ese momento cuando el sistema Java permite al applet controlar el evento. Este control comienza por el Componente que recibe inicialmente el evento. Un controlador de eventos solamente necesita una información: una referencia a la instancia de la clase Event que contiene la información del evento que se ha producido. El valor devuelto por el método handle Event()es importante. Indica al sistema Java si el evento ha sido o no completamente controlado por el controlador. Un valor true indica que el evento ha sido controlado y que su propagación debe detenerse. Un valor false indica que el evento ha sido ignorado, o que no ha sido controlado en su totalidad y debe continuar su propagación hacia arriba en el árbol de Componentes. El sistema Java continúa de este mismo modo hasta que el evento es controlado en su totalidad o ya no hay Componentes a los que informa el código del controlador de eventos.

METODOS DE CONTROL DE EVENTOS

El método handleEvent() es un lugar para que el programador pueda insertar código para controlar los eventos. A veces, sin embargo, un Componente solamente estará interesado en eventos de un cierto tipo (por ejemplo, eventos del ratón). En estos casos, el programador puede colocar el código en un método de ayuda, en lugar de colocarlo en el método handleEvent().

No hay métodos de ayuda para ciertos tipos de eventos, aquí está la lista de los que están disponibles para los programadores:

action( Event evt,Object obj ) gotFocus( Event evt,Object obj ) lostFocus( Event evt,Object obj ) mouseEnter( Event evt,int x,int y ) mouseExit( Event evt,int x,int y ) mouseMove( Event evt,int x,int y ) mouseUp( Event evt,int x,int y ) mouseDown( Event evt,int x,int y ) mouseDrag( Event evt,int x,int y ) keyDown( Event evt,int key ) keyUp ( Event evt,int key )

Algunos de los eventos que más frecuentemente tendremos que controlar son los siguientes:

ACTION_EVENTMOUSE_DOWN



KEY_PRESSWINDOW_DESTROY

En la documentación de la clase Event se encuentra toda la lista de eventos que cualquier aplicación puede necesitar manejar y su documentación; como ejemplo de uso vamos a detenernos en el primero de ellos, ACTION_EVENT.

Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al pulsar un botón, seleccionar un menú, etc. Para su control podemos manejarlo en el método handleEvent() o en el método action().

Los dos métodos anteriores pertenecen a la clase Component por lo que todas las clases derivadas de ésta contendrán estos dos métodos y se pueden sobrecargar para que se ajuste su funcionamiento a lo que requiere nuestra aplicación.

CREACIÓN DE EVENTOS

Mejorar El Diseño De Interfaces

La interface de usuario es el aspecto más importante de una aplicación, tal como ya hemos repetido. Un diseño pobre de la interface es un grave problema para que el usuario pueda obtener todo el partido posible de la aplicación. Para ser efectivos, no debemos limitarnos a colocar una serie de botones, etiquetas y barras de desplazamiento sobre la pantalla. Desafortunadamente, nadie ha determinado una reglas correctas para del diseño de una buena interface.

Cambio De Fuente De Caracteres

El font de caracteres con el que se presenta un texto en pantalla influye mucho en el impacto de una interface. Una interface efectiva no debería utilizar una maraña de fuentes, pero sí que debería utilizar dos o tres diferentes para aumentar el atractivo y la efectividad de los textos.

Utiliza tres tipos de fonts de caracteres (en diferente estilo y diferente tamaño) para llamar la atención del usuario sobre las tres zonas de la interface. La fuente por defecto para todos los Componentes es la fuente Dialog. Java proporciona otras fuentes con propósitos más especializados, el número exacto de fuentes depende de la plataforma, por ello, se puede utilizar el applet ListaFuentes.java para obtener una lista de las fuentes de caracteres disponibles en el sistema.

Cuando un programador necesita presentar un Componente en pantalla, como un objeto TextArea, en una fuente de caracteres distinta a la de defecto, la nueva fuente debe seleccionarse mediante el método setFont():


http://proton.ucting.udg.mx/tutorial/java/Fuentes/Cap4/ListaFuentes.java


public void setFont( Font f )

El método setFont() espera como parámetro una fuente. En el siguiente trozo de código vemos cómo se usa:

TextArea ta = new TextArea(); Font f = new Font( "Helvetica",Font.ITALIC,12 ); ta.setFont( f );Este código con ligeras modificaciones funcionará para cualquier Componente. Si se cambia la fuente de un Contenedor, todos los Componentes colocados dentro del Contenedor automáticamente adoptarán la nueva fuente de caracteres. El siguiente código, CambioFuentes.java, muestra esta circunstancia:import java.awt.*;import java.applet.Applet;

public class CambioFuentes extends Applet {

public static void main( String args[] ) { Frame fr = new Frame( "Cambio de Fuentes" ); CambioFuentes cf = new CambioFuentes();

Font f = new Font( "Helvetica",Font.ITALIC,12 ); fr.setFont( f ); fr.setLayout( new FlowLayout() ); Button b = new Button( "Hola" ); fr.add( b ); Checkbox cb = new Checkbox( "Púlsame" ); fr.add( cb ); TextArea ta = new TextArea(); fr.add( ta );

fr.pack(); fr.show(); } }

La fuente de caracteres solamente se indica para el objeto Frame, el botón, la caja y el área de texto también utilizarán esta fuente.

Colores De Fondo Y Texto

El impacto visual del color nunca debe ser desestimado cuando se ataca el diseño de una interface de usuario. El color tiende a atraer la visión y puede utilizarse para llamar la atención sobre una parte importante del interface. En el ejemplo siguiente, el color rojo alrededor del botón hace que la vista se fije inmediatamente en él.


http://proton.ucting.udg.mx/tutorial/java/Fuentes/Cap4/CambioFuentes.java


La clase Component proporciona dos métodos para modificar el color de un Componente. A través de los métodos setBackground() y setForeground(), se pueden indicar los colores del fondo y del texto, respectivamente:

public void setBackground( Color c ) public void setForeground( Color c )

Ambos métodos solamente necesitan un parámetro, un objeto Color. A continuación mostramos un ejemplo de su uso:

TextArea ta = new TextArea(); ta.setBackground( Color.blue ); ta.setForeground( Color.red );

Este código funcionará con ligeras modificaciones para casi todos los Componentes del AWT. Si se cambia el Color de un Contenedor, todos los Componentes colocados dentro de ese Contenedor, automáticamente adoptan el nuevo color. El applet, CambioColor.java, ilustra este punto. El Color solamente se fija para el color de fondo del objeto Frame; el botón, la caja y el área de texto usarán ese mismo color de fondo.

import java.awt.*;import java.applet.Applet;

public class CambioColor extends Applet {

public static void main( String args[] ) { Frame fr = new Frame( "Cambio de Color" ); CambioColor cc = new CambioColor();

fr.setBackground( Color.red ); fr.setLayout( new FlowLayout() ); Button b = new Button( "Hola" ); fr.add( b ); Checkbox cb = new Checkbox( "Púlsame" ); fr.add( cb ); TextArea ta = new TextArea(); fr.add( ta );

fr.pack(); fr.show(); } }

La calidad de soporte del color varía mucho de una plataforma a otra. Bajo Windows '95, la clase Button ignora totalmente los comandos de color y se empeña en permanecer bajo un patrón de grises. Por otro lado, el fondo de la clase Label parece ser transparente. Algunos Componentes no se presentan en pantalla con un mismo color para un mismo objeto Color. Bajo Windows '95, un fondo de color naranja aparece como naranja en muchos Componentes


http://proton.ucting.udg.mx/tutorial/java/Fuentes/Cap4/CambioColor.java


(excepto en los botones), pero se presenta como amarillo cuando se trata de objetos TextArea o TextField. El soporte del color en Solaris parece ser mucho más consistente.

Fijar El Tamaño Preferido

Otro ingrediente importante de una buena interface es el tamaño con el cual aparecerá un Componente o Contenedor en la pantalla. En el corazón del control de la composición del interface está el layout manager, que es capaz de fijar el tamaño y la posición de los Componentes que se vayan incorporando al layout que está manejando. Esto, indirectamente, también influye en el tamaño del Contenedor.

En este caso, en lugar de llamar a un método para indicar cuál debe ser el tamaño de un Componente, hay que derivar una nueva clase del Componente y redefinir el método preferredSize() que devolverá el tamaño preferido. El layout manager llama al método preferredSize() para determinar cuál debe ser el tamaño preferido para cada Componente.

APPLET

Un applet Java es un applet escrito en el lenguaje de programación Java. Los applets de Java pueden ejecutarse en un navegador web utilizando la Java Virtual Machine(JVM), o en el AppletViewer de Sun.

Entre sus características podemos mencionar un esquema de seguridad que permite que los applets que se ejecutan en el equipo no tengan acceso a partes sensibles (por ej. no pueden escribir archivos), a menos que uno mismo le dé los permisos necesarios en el sistema; la desventaja de este enfoque es que la entrega de permisos es engorrosa para el usuario común, lo cual juega en contra de uno de los objetivos de los Java applets: proporcionar una forma fácil de ejecutar aplicaciones desde el navegador web.

En Java, un applet es un programa que puede incrustarse en un documento HTML, es decir en una página web. Cuando un navegador carga una página web que contiene un applet, este se descarga en el navegador web y comienza a ejecutarse. Esto permite crear programas que cualquier usuario puede ejecutar con tan solo cargar la página web en su navegador.

El navegador que carga y ejecuta el applet se conoce en términos genéricos como el "contenedor" de los applets.

Los applets de Java suelen tener las siguientes ventajas:



* Son multiplataforma (funcionan en Linux, Windows, Mac OS, y en cualquier sistema operativo para el cual exista una Java Virtual Machine).

* El mismo applet puede trabajar en "todas" las versiones de Java, y no sólo la última versión del plugin. Sin embargo, si un applet requiere una versión posterior del Java Runtime Environment (JRE), el cliente se verá obligado a esperar durante la descarga de la nueva JRE.

* Es compatible con la mayoría de los navegadores web.

* Puede ser almacenado en la memoria caché de la mayoría de los navegadores web, de modo que se cargará rápidamente cuando se vuelva a cargar la página web, aunque puede quedar atascado en la caché, causando problemas cuando se publican nuevas versiones.

* Puede tener acceso completo a la máquina en la que se está ejecutando, si el usuario lo permite.

* Puede ejecutarse a velocidades comparables a la de otros lenguajes compilados, como C++ (dependiendo de la version de la JVM).

* Puede trasladar el trabajo del servidor al cliente, haciendo una solución web más escalable tomando en cuenta el número de usuarios o clientes.

Los applets de Java suelen tener las siguientes desventajas:

* Requiere el plugin de Java, que no está disponible por defecto en todos los navegadores web.

* No puede iniciar la ejecución hasta que la JVM esté en funcionamiento, y esto puede tomar tiempo la primera vez que se ejecuta unapplet.

* Si no está firmado como confiable, tiene un acceso limitado al sistema del usuario - en particular no tiene acceso directo al disco duro del cliente o al portapapeles.

* Algunas organizaciones sólo permiten la instalación de software a los administradores. Como resultado, muchos usuarios (sin privilegios para instalar el plugin en su navegador) no pueden ver los applets.

* Un applet podría exigir una versión específica del JRE.

Existen diferencias entre un programa autónomo y un applet:

* Restricciones de seguridad: los applets son considerados código de poca confianza1 (a excepción de que lleven una firma digital) ya que son compartidos por todos los usuarios de Internet. Por ejemplo, no se permite el acceso a ficheros locales ni conectarse a un servidor distinto al que está alojado el applet.



* Necesitan un navegador para ser visualizados, o un visor de applets como appletviewer.

* No tienen un método principal.

Crear un applet

Para crear un applet necesitamos escribir una clave de la clase Applet del paquete java.applet.*;

import java.applet.*;

public class MiApplet extends Applet

{

//Cuerpo del ''applet''.

}

El código anterior declara una nueva clase MiApplet que hereda todas las capacidades de la clase Applet de Java. El resultado es un fichero MiApplet.java.

Una vez creada la clase que compone el applet, escribimos el resto del código y después lo compilamos, obteniendo el fichero MiApplet.class.

~PROGRAMAS~

CALCULADORA

import java.awt.Container;

import java.awt.Font;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Stack;

import javax.swing.JApplet;



import javax.swing.JButton;

import javax.swing.JTextField;

public class CalculadoraApplet extends JApplet implements ActionListener {

private static final long serialVersionUID = 3221707769370092517L;

Container container;

JTextField datos;

JButton b1,b2,b3,b4,b5,b6,b7,b8,b9,b0;

JButton opSuma, opResta, opMult, opDiv;

JButton punto, calcular, limpiar;

Stack<String> pila;

char operacion;

boolean operacionTerminada=false;

public void init(){

container = this.getContentPane();

container.setLayout( new GridLayout(6,1) );

pila = new Stack<String>();

Font fuente = new Font("Verdana", Font.BOLD, 18);

/* Formato del campo de entrada */



datos = new JTextField();

datos.setFont(fuente);

datos.setEditable(false);

limpiar = new JButton("Limpiar");

Container renglon2 = new Container();

renglon2.setLayout( new GridLayout(1,4) );







renglon2.add(b1 = new JButton("1"));



renglon2.add(opSuma = new JButton("+"));






renglon3.add(opResta = new JButton("-"));




renglon4.add(opMult = new JButton("*"));

renglon5.add(punto = new JButton("."));


renglon5.add(calcular = new JButton("="));

renglon5.add(opDiv = new JButton("/"));

/* Aplicando fuente a todos los botones */

b1.setFont(fuente);

b2.setFont(fuente);

b3.setFont(fuente);

b4.setFont(fuente);

b5.setFont(fuente);

b6.setFont(fuente);

b7.setFont(fuente);

b8.setFont(fuente);

b9.setFont(fuente);

b0.setFont(fuente);

opSuma.setFont(fuente);

opResta.setFont(fuente);

opMult.setFont(fuente);

opDiv.setFont(fuente);



punto.setFont(fuente);

calcular.setFont(fuente);

/* Agregando acción a todos los botones */

b1.addActionListener(this);










opSuma.addActionListener(this);

opResta.addActionListener(this);

opMult.addActionListener(this);

opDiv.addActionListener(this);

punto.addActionListener(this);

calcular.addActionListener(this);

limpiar.addActionListener(this);

container.add(datos);

container.add(renglon2);






container.add(limpiar);

}

public void actionPerformed(ActionEvent e) {

if(operacionTerminada){

datos.setText("");

operacionTerminada = false;

}

if( e.getSource()==b1 ){

datos.setText(datos.getText()+1);

}

else if( e.getSource()==b2 ){


}



}





}



}



}



}



}



}



}

else if( e.getSource()==punto ){

//Sólo si no contiene punto lo agrega y sólo que no sea vacío

if( !datos.getText().contains(".") && !datos.getText().equals("") )

datos.setText(datos.getText()+".");

}



else if(e.getSource()==opSuma){

preparaOperacion('+');

}

else if(e.getSource()==opResta){

preparaOperacion('-');

}

else if(e.getSource()==opMult){

preparaOperacion('*');

}

else if(e.getSource()==opDiv){

preparaOperacion('/');

}

else if(e.getSource()==calcular){

calculaOperacion();

}

else if( e.getSource()==limpiar ){

datos.setText("");

pila.removeAllElements();

}

}

private void calculaOperacion() {

if( !datos.getText().equals("") && !pila.isEmpty() ){

if(operacion=='+')



datos.setText( Double.toString( Double.parseDouble( pila.pop() ) + Double.parseDouble( datos.getText() ) ));

else if(operacion=='-')

datos.setText( Double.toString( Double.parseDouble( pila.pop() ) - Double.parseDouble( datos.getText() ) ));

else if(operacion=='*')

datos.setText( Double.toString( Double.parseDouble( pila.pop() ) * Double.parseDouble( datos.getText() ) ));

else if(operacion=='/')

datos.setText( Double.toString( Double.parseDouble( pila.pop() ) / Double.parseDouble( datos.getText() ) ));

}

operacionTerminada = true;

}

private void preparaOperacion(char c) {

operacion = c;

System.out.println("operacion: "+operacion);

if(!datos.getText().equals(""))

pila.push(datos.getText());

datos.setText("");

}

}



EVENTO DE MOUSE

import java.awt.Graphics;

import java.awt.event.*;

import java.applet.Applet;

public class Ratoncito2 extends Applet implements MouseListener {

private int mouseX = 25;

private int mouseY = 25;

//Registrar esta instancia de applet para capturar eventos de

//MouseLister

public void init ( ) {

addMouseListener (this) ;

}



public void paint (Graphics g) {

g.drawString ("Hola Ingenieros en Sistemas", mouseX, mouseY) ;

}

//Procesa el evento MousePressed MouseListener

public void mousePressed (MouseEvent evt) {

mouseX = evt.getX ( ) ;

mouseY = evt.getY ( ) ;

repaint ( ) ;

}

//No estamos usando los otros eventos del mouse.

public void mouseClicked (MouseEvent e) { }

public void mouseEntered (MouseEvent e) { }

public void mouseExited (MouseEvent e) { }

public void mouseReleased (MouseEvent e) { }

}

Código para HTML

<HTML>

<HEAD>

<TITLE> Un applet de Java </TITLE>



</HEAD>

<BODY bgcolor="purple">

<MARQUEE><FONT COLOR="bluelight" FACE="JOKERMAN" size=7>~ Calculadora~</FONT></marquee>

<p align="center">

<applet Code="CalculadoraApplet.class" width="400" height="400" >

</applet>

<applet Code="Ratoncito2.class" width="400" height="400" >

</applet>

</p>

</BODY>



</HTML

EVENTO MOUSE

/*

* Fichero: ArrastrarGrafico.java

* Autor: Chuidiang

* Fecha: 6/06/07 21:40

*/

package chuidiang.ejemplos.arrastrar_grafico;

import java.awt.Canvas;



import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.event.MouseEvent;

import java.awt.event.MouseMotionListener;

import javax.swing.JFrame;

import javax.swing.WindowConstants;

/**

* Ejemplo de gráfico que se puede arrastrar con el ratón.

*

* @author Chuidiang

*

*/

public class ArrastrarGrafico extends Canvas implements MouseMotionListener

{

/**

* serial uid

*/

private static final long serialVersionUID = -4273648398171436938L;

/**

* Posicion x del vértice superior izquierdo del rectángulo.



*/

private int xRectangulo = 0;

/**

* Posicion y del vértice superior izquierdo del rectángulo

*/

private int yRectangulo = 0;

/**

* Ancho del rectángulo

*/

private int anchoRectangulo = 100;

/**

* Alto del rectángulo

*/

private int altoRectangulo = 100;

/**

* Si actualmente se está arrastrando o no el rectángulo.

*/

private boolean arrastrando = false;

/**

* x en la que estaba anteriormente el ratón.



*/

private int xAnteriorRaton;

/**

* y en la que estaba anteriormente el ratón

*/

private int yAnteriorRaton;

/**

* Crea un nuevo objeto ArrastrarGrafico.

*/

public ArrastrarGrafico()

{

addMouseMotionListener(this);

}

/**

* Para darle un tamaño por defecto al Canvas de dibujo

*

* @return Dimension por defecto.

*/

@Override

public Dimension getPreferredSize()

{

return new Dimension(500, 500);



}

/**

* Dibuja el rectángulo en la posición indicada por por xRectangulo e

* yRectangulo.

*

* @param g Graphics con el que dibujar.

*/

@Override

public void paint(Graphics g)

{

g.setColor(Color.GREEN);

g.fillRect(xRectangulo, yRectangulo, anchoRectangulo, altoRectangulo);

}

/**

* Crea la ventana con el Canvas y lo visualiza

*

* @param args Se ignoran

*/

public static void main(String[] args)

{

JFrame v = new JFrame("Arrastrar Grafico");

ArrastrarGrafico c = new ArrastrarGrafico();

v.getContentPane().add(c);



v.pack();

v.setVisible(true);

v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

}

/**

* Método al que se llama cuando se arrastra el ratón.

* Se comprueba con el atributo arrastrando si está empezando el arrastre o

* ya se esta en medio del mismo.

* Si se comienza el arrastre, se guardan las coordenadas del ratón que

* vienen en el evento MouseEvent y se cambia el valor del atributo arrastrando.

* Si se está en medio de un arrastre, se calcula la nueva posición del

* rectángulo y se llama al método repaint() para que se pinte.

*

* @param e Evento del ratón

*/

public void mouseDragged(MouseEvent e)

{

// Si comienza el arrastre ...

if (!arrastrando)

{

// ... y el ratón está dentro del rectángulo

if (estaDentro(e))

{



// Se guardan las posiciones del ratón

xAnteriorRaton = e.getX();

yAnteriorRaton = e.getY();

// y se marca que ha comenzado el arrastre.

arrastrando = true;

}

}

else

{

// Si ya había empezado el arrastre, se calculan las nuevas

// coordenadas del rectángulo

xRectangulo = (xRectangulo + e.getX()) - xAnteriorRaton;

yRectangulo = (yRectangulo + e.getY()) - yAnteriorRaton;

// Se guarda la posición del ratón para el siguiente cálculo

xAnteriorRaton = e.getX();

yAnteriorRaton = e.getY();

// y se manda repintar el Canvas

repaint();

}

}

/**

* Para ver si el ratón está dentro del rectángulo.



* Si está dentro, puede comenzar el arrastre.

*

* @param e El evento de ratón

*

* @return true si el ratón está dentro del rectángulo

*/

private boolean estaDentro(MouseEvent e)

{

if (

(e.getX() > xRectangulo) &&

(e.getX() < (xRectangulo + anchoRectangulo)) &&

(e.getY() > yRectangulo) &&

(e.getY() < (yRectangulo + altoRectangulo)))

{

return true;

}

return false;

}

/**

* El ratón se mueve sin arrastrar. Se marca fin de arrastre.

*

* @param e E

*/



public void mouseMoved(MouseEvent e)

{

arrastrando = false;

}

}



BIBLIOGRAFIA

http://www.slideshare.net/javi2401/eventos-en-java-presentation


http://www.slideshare.net/javi2401/eventos-en-java-presentation

eventos y applets

Documents