AWT

Abstract Windowing Toolkit.

(Kit de Herramientas para ventanas abstractas).

 

Presenta: Miguel Miranda Miranda.

 

 

 

(Imágenes AWT1 y AWT2).

 

 

 

Componentes.

Los componentes son los objetos de interfaz de usuario fundamentales en Java.

Todos los elementos visibles en una aplicación Java son componentes AWT.

Estos pueden ser:

 

Contenedores.

Son componentes especiales que contienen y administran otros componentes. Los componentes que están dentro del contenedor se les conoce como componentes hijos (child). El contenedor tiene una lista de todos sus hijos y proporciona el método add() para agregar nuevos componentes al contenedor.

Algunos contenedores son:

en Frames u otros Panels.

Applet: Descendiente de Panel.

 

Applets.

Un applet es básicamente un Panel que espera ser insertado en un documento y ser usado por un medio ambiente de visualización que le proporcione recursos especiales (appletviewer, navegadores).

La clase Applet contiene cuatro métodos que un applet puede sobreescribir para

ayudarlo a través de su ciclo de vida:

init(): es llamado solo una vez, cuando el applet es instanciado.

start(): es llamado cuando el applet se vuelve visible.

stop(): es llamado cuando el applet se vuelve invisible.

destroy(): su llamada depende del visualizador. Por ejemplo Netscape

Navigator llama a destroy() antes de borrar el applet de su caché.

 

Frames.

Generalmente las aplicaciones que no requieren applets instancían la clase Frame para obtener un objeto que será el contenedor de los componentes de la aplicación.

 

Manejadores de trazado (Layouts Managers).

Son objetos que controlan la posición y tamaño de los componentes dentro del área de dibujo de un contenedor. Cada contenedor tiene un manejador de trazado por omisión, pero puede instalarse fácilmente uno nuevo llamando al método setLayout().

Los manejadores de trazado básicos son:

· CardLayout.

 

 

 

(Imágenes Layout, IntLay, EntWin, Gemela, AWTPeer y EvPeer).

 

 

 

Manejo de eventos en Java 1.0

 

La clase Event representa todos los eventos. Esta clase tiene variables de instancia que describen el evento:

 

Los eventos de Java 1.0 se envían primero al método handleEvent() del Componente donde ocurrieron. La instrumentación por omisión de este método verifica el campo id del objeto Event y envía los tipos de eventos más usados a los diferentes métodos específicos:

action() lostFocus() mouseExit()

gotFocus() mouseDown() mouseMove()

keyDown() mouseDrag() mouseUp()

keyUp() mouseEnter()

 

La clase Component define los métodos listados arriba. Para procesar eventos en una aplicación se debe crear una subclase del componente y definir comportamiento personalizado invalidando los métodos para procesar eventos.

 

import java.applet.*;

import java.awt.*;

 

public class Escribir1 extends Applet {

private int ultimox, ultimoy;

 

Button boton_limpiar;

Graphics g;

 

// Inicializa el botón y el objeto Graphics

public void init() {

boton_limpiar = new Button( "Limpiar" );

this.add( boton_limpiar );

g = this.getGraphics();

}

 

// Responde a los clics del ratón

public boolean mouseDown( Event e, int x, int y ) {

ultimox = x; ultimoy = y;

return true;

}

 

// Responde a los arrastres del ratón

public boolean mouseDrag( Event e, int x, int y ) {

g.setColor( Color.black );

g.drawLine( ultimox, ultimoy, x, y );

ultimox = x; ultimoy = y;

return true;

}

 

// Responde a la tecla presionada

public boolean keyDown( Event e, Object arg ) {

if ( e.target == boton_limpiar ) {

limpiar();

return true;

}

else return false;

}

 

// Método conveniente para limpiar el dibujo

public void limpiar() {

g.setColor( this.getBackground() );

g.fillRect(0, 0, bounds().width, bounds().height );

}

}

 

 

 

Manejo de eventos en Java 1.1

 

 

(Imagen Event11)

 

 

Diferentes clases de Java representan las distintas clases de eventos. Cada evento tiene un objeto fuente que puede obtenerse con getSource(), y cada evento AWT tiene un tipo de valor que puede obtenerse con getID(). Este valor sirve para distinguir los diferentes tipos de eventos que se representan por la misma clase de evento.

Un evento fuente notifica algo a un objeto oyente de evento al invocar un método sobre éste y pasarle un objeto de evento. Para que una fuente invoque a un método sobre un oyente, todos los oyentes deben instrumentar el método requerido. Una interfaz oyente de evento quizá defina más de un método. Para cada una de éstas interfaces el paquete event define un simple "adaptador" de clase que proporciona un cuerpo vació para cada método en la interfaz.

 

 

(Imagen AWTEVENT)

 

 

 

 

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

 

public class Escribir2 extends Applet {

int ultimo_x, ultimo_y;

 

public void init() {

// Define, instancia y registra un objeto

// MouseListener.

this.addMouseListener( new MouseAdapter() {

public void mousePressed( MouseEvent e ) {

ultimo_x = e.getX();

ultimo_y = e.getY();

}

} );

 

// Define, instancia y registra un objeto

// MouseMotionListener.

this.addMouseMotionListener( new MouseMotionAdapter() {

public void mouseDragged( MouseEvent e ) {

Graphics g = getGraphics();

int x = e.getX(), y = e.getY();

g.setColor( Color.black );

g.drawLine( ultimo_x, ultimo_y, x, y );

ultimo_x = x; ultimo_y = y;

}

} );

 

// Crea un botón limpiar

Button b = new Button( "Limpiar" );

// Define, instancia y registra un oyente para

// manejar el botón presionado

b.addActionListener( new ActionListener() {

public void actionPerformed( ActionEvent e) {

Graphics g = getGraphics();

g.setColor( getBackground() );

g.fillRect( 0, 0, getSize().width, getSize().height );

}

} );

 

// Y agrega el botón al applet.

this.add(b);

}

}

 

 

Dibujado y Redibujado de componentes.

Los componentes pueden dibujarse asimismos por medio de una llamada al método paint(). Este método es invocado cuando el objeto se hace visible por primera vez, si cambia de apariencia o si algún otro elemento que lo oculte es removido. Si solamente una pequeña parte del componente cambia puede llamarse al método update(), que define una región de recorte para limitar la extensión del área a ser pintada. Un componente nunca llama directamente a update(), sino que llaman a repaint() el cual registra una llamada a update() que será ejecutada en el futuro. update() y paint() toman un argumento: un objeto Graphics el cual representa el contexto gráfico del componente.

Contexto gráfico: Contiene infomación contextual del área de dibujo: área, región de recorte, modo de transferencia, y font para texto. También proporciona los métodos para dibujado de primitivos y manipulación de imágenes.

Todos los componentes usan los mecanismos de paint y update, sin embargo solamente se deben implementar estos métodos cuando se requieren dibujos en objetos Canvas y Panel.

 

Otras clases del AWT.

Fonts: Los textos en Java son representadas por instancias de esta clase. Se construyen definiendo nombre, identificador de estilo y tamaño.

Color: Describe los colores a partir de sus componentes RGB.

 

import java.applet.*;

import java.awt.*;

 

public class HolaMundo extends Applet {

static final String mensaje = "Hola Mundo";

private Font fuente;

Image imagen;

 

public void init() {

fuente = new Font("Helvetica", Font.BOLD, 48);

imagen = getImage(getCodeBase(), "T1.gif");

}

 

public void paint( Graphics g ) {

g.setColor(Color.pink);

g.fillOval(10, 10, 330, 100);

g.setColor(Color.red);

g.drawOval(9, 9, 332, 102);

g.drawOval(8, 8, 334, 104);

 

g.setColor(Color.black);

g.setFont(fuente);

g.drawString(mensaje, 40, 75);

g.drawImage( imagen, 0, 0, this);

}

}

 

 

La clase imagen y el paquete de imagen.

El AWT proporciona una clase java.awt.Image. Referencias de Image se pasan a métodos en otros objetos AWT, por ejemplo para dibujar en un componente se invoca el método Graphics.drawImage(Image, int, int, ImageObserver).

Image es una clase abstracta que define métodos que proporcionan información acerca de la imagen. La infraestructura para crear y manipular imágenes reside en el paquete java.awt.image, que define interfaces para producir y obtener una imagen. También contiene clases para manipulación y filtrado de imágenes.

Productor de imagen (ImageProducer): Es responsable de producir los bits de una imagen y pasarlos al Observador de imagen. Notifica su progreso invocando al

método imageUpdate().

Observador de imagen (ImageObserver): Monitorea el estado de la imagen y

proporciona la información acerca de la disponibilidad de la imagen al resto de la

aplicación.

Métodos para el mejorar la velocidad de despliegue en imágenes.

Recorte (Clipping): Este método de la clase Graphics restringe el área de dibujo de un contexto gráfico a una región más pequeña. Podemos definir una regíon de recorte con clipRect().

Doble Buffer: Es una copia de la imagen en pantalla (o una región de recorte) en un buffer de memoria. Este buffer actualiza instantáneamente nuestro dibujo cuando esta listo.

 

Bibliografía y referencias.

Los diagramas de jerarquías de clases y los programas ilustrativos fueron tomados de :

 

Flanagan David. "Java en pocas palabras". Edit. McGraw Hill. O’Reilly. Segunda Edición.

 

Los dibujos ilustrativos de sobre el funcionamiento interno de Java fueron tomados de :

Niemeyer Patrick & Peck Joshua. "Exploring Java". Edit. O’Reilly.

 

Geary David M. & McClellan Alan L. "Graphic Java. Mastering the AWT". Edit. Prentice Hall.

 

El esquema del modelo de programación en Windows fue tomado de :

Adams Lee. "Programación avanzada de gráficos en C para Windows". Edit McGraw Hill.

 

Un libro que todo aspirante a programador en Java debe leer es :

Ken Arnold & Gosling James. "El lenguaje de programación Java". Edit. Addison-Wesley/DOMO.