• AWT: Abstract Window Toolkit.

• Un widget es un elemento gráfico con el que el usuario puede interactuar.

• Ocupa una porción rectangular en una ventana.

• Existen diversos tipos: botones, áreas de texto, etiquetas, etc.

• El kit AWT implementa los widgets más usuales. Para usarlos es necesario importar las clases del paquete java.awt:

  import java.awt.*;
  

Los widgets se organizan en una jerarquía cuya raíz es la ventana de la aplicación.

• Los botones, áreas de texto, etiquetas, etc. son hojas en la jerarquía.

• Los nodos internos se denominan contenedores:
  • Frame: Una ventana.
  • Panel: Una porción rectangular de una ventana pre-existente.
  • Applet: Un panel dentro de un browser Web.
  • FileDialog: Una ventana para que el usuario seleccione un archivo.

• Los widgets se implementan como extensiones de la clase Component.

• Construcción del Frame:

  Frame frame= new Frame("Titulo de la ventana");
  

• Construcción de widgets básicos de interacción:

  Botón:	Button boton= new Button("nombre del boton");
  Etiqueta:	Label etiq= new Label("nombre", Label.CENTER);
  Area de texto:	TextArea area= new TextArea(5, 20);
  Campo de texto:	TextField texto= new TextField(15);
  Botón on/off:	Checkbox check= new Checkbox("nombre");

La lista de ítemes:

   List lista = new List(3);
   for (int i = 1; i <= 10; i++) {
     lista.addItem("List item " + i);
   }

   Panel panel= new Panel();

• No es conveniente asignar a los widget posiciones absolutas dentro de la ventana.

• Para organizar el contenedor se le asigna un layout manager usando setLayout:

    frame.setLayout(new BorderLayout());
    panel.setLayout(new FlowLayout());
  

• El layout manager elige la mejor posición y tamaño de cada widget de acuerdo al espacio disponible.

Se colocan los widgets en los contenedores:

• Los botones y el campo de texto dentro del panel:

  panel.add(texto);
  panel.add(boton);
  panel.add(check);
  

• La etiqueta, el área de texto y la lista en la ventana:

  frame.add("North", etiq);
  frame.add("West", area);
  frame.add("East", lista);
  

El panel se trata como si fuese un solo widget:

frame.add("South", panel);

frame.pack();
frame.show();

• Un bean es un objeto inspeccionable por ambientes de desarrollo rápido (un RAD, un builder).

• Con un RAD, el programador puede generar rápidamente el código que construye la ventana de su aplicación.

• El programador diseña la interfaz gráfica arrastrando beans hacia la ventana de diseño.

• El RAD provee de una paleta de beans.

• Ejemplos de RAD: JBuilder de Borland, PowerJ de PowerSoft, Java WorkShop de Sun, Cafe de Symantec, etc.

• Cuando la paleta de beans no ofrece el widget que se necesita, entonces se fabrica con un Canvas.

• Para hacer un widget se extiende la clase Canvas.

• El nuevo widget se agrega a la ventana como si fuese un widget cualquiera.

  Canvas canvas= new MiCanvas();
  frame.add("Center", canvas);
  

• Cumpliento algunos requisitos, el nuevo widget se puede agregar a la paleta de beans de cualquier RAD.

class MiCanvas extends Canvas {
    public void paint(Graphics g) {
        int w = getSize().width;
        int h = getSize().height;
        g.drawLine(10,10, 100,100);
    }

    public Dimension getMinimumSize() {
        return new Dimension(150,130);
    }

    public Dimension getPreferredSize() {
        return getMinimumSize();
    }
}

• Los widgets deben responder a los eventos que genera el sistema gráfico debido a la interacción con el usuario.

• El sistema gráfico invoca el método paint de un widget cuando se descubre alguna parte de él.

• El layout manager invoca los métodos getMinimumSize y getPreferredSize para obtener hints acerca del mejor tamaño del widget.

• La mayoría de los widgets (como botones, etiquetas, texto, etc.) ya tienen redefinidos estos métodos en forma conveniente.

• El canvas sirve para implementar nuevos widgets, cuando ninguno de los widgets disponibles es apropiado.

public class Gui extends Frame { // Se especializa la ventana
  Button boton;  // Se crean variables de instancia
  List lista;    // para cada widget
  ...
  public Gui() { // El constructor para la ventana
    setLayout(new BorderLayout()); // asigna el layout
    boton= new Button("quit"); // crea los widgets
    ...
    add("West", area); // Arma la ventana
    ...
  }
  public static void main(String[] args) { // El main
    Frame frame= new Gui(); // Crea la ventana,
    frame.pack();           // la despliega
    frame.show();           // y termina
} }

Una vez armada la ventana, todo el proceso se hace atrapando los eventos que produce el usuario al interactuar con los widgets.

Ejercicio 1: Copie Gui.java a su directorio. Compile y ejecute.

Ejercicio 2: Construya una aplicación que cree una ventana con:

• area: un área de texto al centro.
• lista: una lista a la izquierda.
• texto: un campo de texto abajo.
• etiq: una etiqueta "Libreta de teléfonos" arriba.
• boton: un botón "borrar" a la derecha.