Java Foundation Classes -JFC-ü Es un conjunto de paquetes Java, que agrupa a las siguientes interfaces de
programación (API’s):ü Abstract Window Toolkit (AWT 1.1 y posteriores): es un toolkit Java que
permite desarrollar interfaces de usuario. Es el fundamento de JFC.ü Componentes Swing: implementan un nuevo conjunto de componentes de GUI con
“look & feel” configurable. Reemplazan a las componentes de GUI heavyweigthdel AWT por componentes lightweigth.
ü Java 2D: es un conjunto de clases que permiten manipular gráficos 2D avanzadose imágenes.
ü Accesibility: consiste en un conjunto de clases que permiten a las componentesSwing interactuar con tecnologías que ayudan a los usuarios con discapacidades.
ü El corazón de la JFC es el AWT (1.1 ó superior), el cual provee la siguienteinfraestructura:ü Modelo de eventos basado en delegaciónü Componentes Lightweightü Servicio de portapapeles (clipboard) y transferencia de datos desde y hacia el
portapapelesü Impresión y operaciones sin mouse (navegación con teclas, abreviaturas de
menúes)ü La JFC se incorporó a la API Java a partir de la versión 1.2 del JDK.
Abstract Window Toolkit -AWT-El AWT es un mundo de componentes de GUI. Aproximadamente la mitadde las clases del AWT son subclase de la clase java.awt.Component.El fundamento del AWT lo constituyen:üClase Component: es una clase abstracta que agrupa componentes
GUI éstandares como botones, menúes, listas, labels, etc.üClase Container: es una clase abstracta, subclase de Component.
Tiene la capacidad de contener múltiples componentes. Applet, Panel,Window, Dialog y Frame son subclases de Container.üInterfaz LayoutManager, LayoutManager2: son interfaces que
definen métodos para la ubicación, la distribución y el cambio detamaño de las componentes dentro de un contenedor. Java proveevarias clases que implementan estas interfaces.üClase Graphics: es una clase abstracta que define métodos para
realizar operaciones gráficas sobre una componente (mostrarimágenes, texto, establecer colores y fonts). Toda componente AWTtiene asociado un objeto Graphics donde dibujarse.
AWT. Las Clases Component y Containers,la Interfaz Layout Manager
üLa relación fundamental en AWT se establece entre objetos:Component, Container y Layout Manager.
üAWT establece una relación simple y fundamental entre objetosComponent y Container: los containers pueden contener components.
üTodos los containers tienen asociado un layout manager (excepto laclase java.awt.Container) que establece la ubicación y la forma de lascomponentes del Container.
üLas responsabilidades del layout manager las definen las interfacesjava.awt.LayoutManager y java.awt.LayoutManager2.
La clase java.awt.Component es una clase abstracta queprovee una amplia funcionalidad, heredada por todas sussubclases. Los controles de la interfaz de usuario comobotones, scrollbars, labels, text, fields, etc. son subclase dejava.awt.Component. Cada componente AWT tiene asociadala siguiente información:
ü Un objet Graphics (donde dibujarse)ü Posiciónü Tamañoü Peer nativo (componente de GUI nativa)ü Container padreü Fonts y dimensiones del fontü Colores de foreground y de backgroundü Tamaño mínimo, máximo y preferido
Componentes AWT
Componentes AWT estándaresPanel
Button
TextArea
Choice
Label
ScrollBar
Checkbox
List
TextField
Canvas
ScrollPane
Componentes AWT y Peers
üEl AWT original (versión 1.0) basó el diseñode sus componentes de GUI en peers.üLos peers son componentes de GUI nativas
(del sistema donde se ejecutan) manipuladaspor componentes AWT. Las clases AWTencapsulan a los peers.üLas componentes AWT estándares delegan en
los peers la mayor parte de su funcionalidad.
üCada componente AWT tiene una componente peer (nativa)equivalente.üEjemplo: cuando se usa el AWT para crear una instancia de la claseMenu, la JVM crea una instancia de un menu peer. Es el peer el que haceel trabajo real de desplegarse y manejar el comportamiento del menú.En este caso, el JDK de Solaris creará un objeto menú peer Motif; elJDK de Windows’95 creará menú peer Windows’95; el JDK de Macintoshcreará menú peer Macintosh, etc.
Componentes AWT y Peers
El programa JAVA crea y despliega una componente AWT, quien a su vez crea y despliega una componentesnativa -peer-.
Programa Java Java AWTSistema deVentanas
Nativo, Peers
Presentación Windows’95MACMotif
Componentes AWT y Peers
Ventajas y desventajas del diseño basado enpeers:
El diseño basado enpeers no es escalable.
Desventajas
Retiene el “lookand feel” de laplataformadonde seejecuta elapplet ó laaplicación.
Evita reimplementar lafuncionalidad provistapor las componentesnativas de GUI.
Ventajas
Componentes AWTHeavyweigth
ü Las componentes AWT estándares son heavyweigth:üTienen un peer nativo, por lo tanto no pueden extenderse
para modificar el comportamiento por defecto.üSe pintan en su propia ventana nativa. En general tienen
forma rectangular y no son transparentes.ü En la versión 1.0 del AWT la implementación de componentes
personalizadas (por ej. un botón con imágenes) implicabaextender la clase java.awt.Canvas (ó java.awt.Container paraimplementar un contener). No se podían extenderjava.awt.Component ni java.awt.Container. Estas clasessolamente podían ser subclaseadas por clases del paquetejava.awt ya que sus constructores tenían alcance de paquete.
Componentes AWTLightweigth
üEl AWT 1.1 introduce componentes de GUI lightweigth:üNo están basadas en peers.üSe pintan en la ventana de su contenedorheavyweigth (en el objeto graphic del contenedor).Tienen forma inorgánica y son transparentes.üSe implementan extendiendo las clasesjava.awt.Component ó java.awt.Container.
ü Las componentes lightweigth necesitan un contenedorheavyweigth donde dibujarse (por eso sontransparentes). Esto no es un inconveniente ya que lascomponentes residen en un Applet ó en un Frame que soncontenedores heavyweigth (en el caso de aplicaciones).
Componentes AWTLightweigth
ü La manipulación de las componentes lightweigth es igual ala de las heavyweigth. Esto es, se establece la posición, seagregan a los contenedores, se pintan, etc..
ü Las componentes lightweigth NO tienen un objeto gráficopropio donde pintarse.
ü Los contenedores lightweigth NO tienen layout managerpreestablecido. Es necesario establecer un layoutmanager ó ubicar en forma manual cada una de suscomponentes.
ü Las componentes Swing provistas en el JDK 1.2 sonlightweigth y reemplazan a las componentes AWTheavyweigth. Además proveen componentes de GUIadicionales como tablas, árboles, cajas de diálogo.
üEn AWT las componentes se pintan de acuerdo aun:üRequerimiento del sistema:
El sistema le pide a la componente que despliegue sucontenido, usualmente porque la componente es laprimera vez que se muestra en la pantalla ó cambia detamaño ó necesita ser reparada (por ej. un objeto queantes la tapaba parcialmente se movió).üRequerimiento de la aplicación:
La componente decide que necesita actualizar sucontenido debido a que su estado interno cambió (por ej.al presionar un botón mostrarlo con apariencia dehundido).
Pintar componentes en AWT
üAWT usa un mecanismo de “callback” para pintarlas componentes. Esto significa que el programadebe sobreescribir un método particular ubicandoallí el código para pintar y el AWT se encarga deinvocar este método en el momento preciso(cuando se necesita pintar la componente).üEste mecanismo es similar para las componentesheavyweigth y lightweigth.üEl método que debe sobreescribirse es:
public void paint (Graphics g)El objeto Graphics pasado como
parámetro debe pre-configurarse con elestado apropiado: color, fonts, área que
necesita ser reparada
Pintar componentes en AWT
üNo es recomendado desde un programa invocardirectamente al método paint().üLos métodos de java.awt.Component:public void repaint()public void repaint(long tm)public void repaint(int x, int y, int width, int heigth)public void repaint(long tm, int x, int y, int width, int heigth)
Permiten que los programas realicen unrequerimiento explícito de pintado en formaasincrónica.üEl método repaint() causa que TODA lacomponente se pinte. Los métodos repaint conargumentos permiten definir la región que necesitarepararse.
Pintar componentes en AWT
Requerimiento de pintado decomponentes
El AWT causa que un thread invoque almétodo update() sobre la componente.
Si la componente no sobreescribe el métodoupdate(), la implementación por defectolimpia el background de la componente einvoca al método paint().
El programa invoca al método repaint() sobrela componente. Esto causa que se registre unpedido asincrónico al AWT para que se vuelvaa pintar la componente.
El AWT causa que un thread invoque almétodo paint() sobre la componente
El programa determina que toda ó parte deuna componente necesita volver a pintarse inrespuesta a un cambio de estado interno.
El AWT determina que toda ó parte deuna componente necesita ser pintada.El AWT causa un PaintEvent
Originado desde una aplicaciónOriginado desde el sistema
Si la componente heavyweigthnecesita actualizarse
continuamente (por ej. unaanimación ), el método update()
debe sobreescribirse para invocarsólo al paint(). Eliminando el
borrado de la componente, sereduce el papadeo
Requerimiento de pintado decomponentes
üSi la componente es lightweigth, cuando elcontenedor padre pinta su ventana, debe propagar lainvocación al método paint() sobre todos susdescencientes lightweigth visibles. El método paint()de java.awt.Container (definido en AWT 1.1), es elencargado de invocar al método paint() sobre todossus componentes lightweigth visibles.üEs fundamental que toda subclase de Container(lightweigth ó heavyweigth) que sobreescriba elmétodo paint() invoque al super.paint() paraasegurar que sus componentes lightweigth se pinten.En otro caso, las componentes ligthweigth no se ven.
Paquetes del AWT
soporte de impresiónjava.awt.printinterfaces peers para componentes peersjava.awt.peermétodos inputjava.awt.imgeometría 2Djava.awt.geomfonts 2Djava.awt.fontsoporte de drag and dropjava.awt.dndmanejo de coloresjava.awt.colortecnologías para asistir al usuariojava.awt.accessibilityclases para manipulación de imágenesjava.awt.image
soporte para clipboard y transferencia dedatos
java.awt.datatransferclases de eventos e interfaces listenersjava.awt.event
funcionalidad de las componentes básicas deGUI
java.awtDescripciónPaquetes AWT
üLa clase java.awt.Container es una clase abstracta, subclase dejava.awt.Component. Los objetos Container son simplemente componentesAWT que pueden contener otras componentes.
üTodo objeto Container tiene una referencia a un objetoLayoutManager, que es el responsable de ubicar y distribuir lascomponentes. Cada vez que ocurre un evento que provoca que elcontenedor tenga que acomodar sus componentes (por ej. cambió eltamaño de la ventana), el layout manager del contenedor es invocado parareacomodar las componentes. Diferentes layout managers implementandiferentes algoritmos para reubicar componentes.
üLa clase Applet es subclase de Panel, que a su vez es subclase deContainer, por lo tanto las applets heredan toda la capacidad de contenery acomodar componentes sobre la pantalla. Así se simplifica el diseño delas applets.
AWT - Containers
AWT - Containers
No tiene menubar ni borde.Es la superclase de Frame y Dialog.
Window
Permite hacer “Scroll” de unacomponente.
ScrollPane
Es un simple contenedor.Panel
Es subclase de Window.Es el contenedor de las aplicaciones.Puede contener un menubar.
Frame
Es un Dialog para elegir archivos.FileDialog
Es subclase de Window.Puede ser modal o no-modal.
Dialog
Es subclase de Panel.Es la superclase de todas las applets.
Applet
DescripciónSubclases
AWT - Layout ManagerüLos containers delegan en el layout manager todo lorelacionado a la ubicación, tamaño, espaciado y distribución desus componentes en la pantalla.
üLa interfaz LayoutManager define métodos para calculartamaños mínimos y preferidos de sus contenedores y ubicarlas componentes en un contenedor.
üUn contenedor tiene exactamente un Layout Manager y unLayout Manager resuelve el trabajo de más de un contenedor.
üEl AWT define cinco clases que implementan las interfacesLayoutManager o LayoutManager2 (son los layouts queestablecen restricciones sobre las componentes):BorderLayout, CardLayout, FlowLayout, GridBagLayout yGridLayout
AWT - Layout Manager
Ubica las componentes en una grilla de celdas de igual tamaño.GridLayout
Es el layout más sofisticado y flexible. Ubica las componentes en unagrilla de filas y columnas, permitiendo que algunas componentes usen másde una celda. No todas las filas tienen la misma altura, ni todas lascolumnas el mismo ancho.
GridBagLayout
Es el layout por defecto de objetos Panel. Ubica las componentes deizquierda a derecha, usando nuevas filas si es necesario. Es posiblealinear las componentes y establecer el espaciado entre las componentes.
FlowLayout:
Es usado para contener en una misma área diferentes componentes enmomentos diferentes. Frecuentemente es controlado por un objetoChoice.
CardLayout
Es el layout por defecto de objetos Window. Establece restriccionesespecificadas mediante strings sobre las componentes : North, South,East, West, Center. Además es posible especificar el espaciado entre lascomponentes.
BorderLayout
AWT - FlowLayoutü Es el layout manager por defecto de Panel.ü El FlowLayout acomoda las componentes del container en una fila, centradasy con su tamaño preferido. Si el espacio horizontal del container no essuficiente para ubicar a todas las componentes en una fila, el FlowLayoututiliza múltiples filas.ü El FlowLayout tiene tres constructores:
üFlowLayout()üFlowLayout(int alineacion): establece diferentes alineaciones de las componentes(izquierda, derecha, centrado).üFlowLayout(int alineacion, int horizEsp, int vertEsp): establece un espaciadohorizontal y vertical entre componentes.
setLayout(new FlowLayout());..................add(new Button(“Button 1”));add(new Button(“2”));add(new Button(“Button 3”));add(new Button(“Long-Named Button 4”));add(new Button(“Button 5”));
AWT - BorderLayoutü Es el layout manager por defecto de Window (Dialog y Frame).ü El BorderLayout usa cinco áreas para acomodar las componentes delcontainer: North, South, East, West y Center. Al agrandar la ventana, el áreacentral es la que ocupará la mayor parte del espacio disponible, las restantesáreas se expanden solamente lo necesario como para completar el espacio. Pordefecto, el BorderLayout no usa espaciado entre componentes.
setLayout(new BorderLayout());..................add(“North”, new Button(“North”));add(“South”, new Button(“South”));add(“East”, new Button(“East”));add(“West”, new Button(“West”));add(“Center”, new Button(“Center”));
public class UIDemo extends Applet { Button b1,b2; Checkbox c1; Label l1; public void init(){ b1=new Button();
b1.setLabel(“Botón 1”); ................ b2=new Button(“Botón 2”);
................ c1=new Checkbox(“Checkbox 1”,false);
l1=new Label(); l1.setText(“Label 1”); l1.setAlignment(label.RIGHT);
//Agrega Componentes usando el FlowLayout (layout manager de default) add(b1); add(b2); add(c1); add(l1); }}
AWT - Ejemplo
Agrega las componentes de la GUI al applet
Container
üA partir del AWT 1.1, el manejo de eventos de la GUI estábasado en el modelo de delegación. La versión original delAWT basó su manejo de eventos en herencia.üLa premisa del modelo de delegación de eventos es simple:objetos que disparán ú originan eventos llamados fuentes delevento y objetos que escuchan y atienden esos eventosllamados listeners del evento.üLos objetos que disparán eventos son las componentes deGUI (fuentes generadoras de eventos) y, delegan el manejode los mismos a los objetos listeners.üLos objetos listeners son registrados sobre las componentesinvocando al método: addXYZListenter(XYZListener).üLuego de la registración, los métodos apropiados del listenerserán invocados cuando el tipo de evento correspondienteocurra sobre la componente.
Manejo de Eventos en AWT 1.1
Manejo de Eventos en AWT 1.1üLas componentes que generan eventos implementan un método para laregistración de listeners (por ej. Button.addActionListener(ActionListener)y Button.removeActionListener(ActionListener)). De esta manera, losobjetos listeners de un tipo determinado pueden registrar interés ódesregistrar interés en los eventos que la componente dispara.üCuando un evento ocurre, la componente que lo originó instancia un eventoapropiado que es pasado al/los listeners que se registraron sobre lacomponente.üLos listeners son los responsables de implementar métodos para el manejode eventos. Estos métodos tienen como parámetro un objeto evento quecontiene información acerca del evento y al objeto que originó el evento.
Fuente de Eventos
Listener de Eventos
Ocurre un Evento
fuente.addListenerType(new ListenerType())1)
2)
3) Se instancia un evento de un tipo apropiado (event)
4) listener.eventHandler(event)
AWT - Clases de Eventos
MOUSE_CLICKEDMOUSE_ENTEREDMOUSE_EXITEDMOUSE_PRESSEDMOUSE_RELEASED...................
EventObject
AWTEvent
ActionEvent AdjustmentEvent ItemEvent TextEvent
ContainerEvent FocusEvent PaintEvent WindowEvent
KeyEventMouseEvent
Objeto que generó el evento
A
CompomentEvent
InputEvent
WINDOW_ACTIVATEDWINDOW_DEACTIVATEDWINDOW_OPENEDWINDOW_CLOSEDWINDOW_ICONIFIED
La clase java.util.EventObject es uno de los fundamentos del modelo de delegación de eventos.En el modelo de delegación de eventos estructura los eventos por clases de eventos relacionados.
A
Eventos para activar,desactivar, cerrar, abrir,minimizar y maximizarventanas.
AWT - Interfaces EventListener
EventListener
Action-Listener
AdjustmentListener
Component-Listener
Focus-Listener
Text-Listener
Window-Listener
MouseMotion-Listener
Mouse-Listener
Container-Listener
KeyListener
Item-Listener
Las interfaces EventListener residen en los paquetes java.util y java.awt.event
actionPerformed(ActionEvent)
mouseClicked(MouseEvent)mouseEntered(MouseEvent)mouseExited(MouseEvent)mousePressed(MouseEvent)mouseReleased(MouseEvent)
textValueChanged(TextEvent)
ü En el paquete java.awt.event se definen once (11)interfaces para los diferentes tipos de eventos.
ü Cada interfaz listener define métodos que seráninvocados cuando ocurre un evento específico. Porejemplo, la interfaz ActionListener define un métodoactionPerformed() que es invocado cuando un eventoaction es disparado por una componente (por ej. unbotón).
ü Los listeners asociados a una componente son losencargados de interceptar y atender los eventosgenerados por la componente para los que el listenerregistró interés.
AWT - Interfaces EventListener
import java.awt.*;import java.awt.event.*;import java.applet.Applet;
public class BotonTest extends Applet implements MouseListener {public void init () {
Button boton = new Button(“Click”);boton.addMouseListener(this);add(boton);
}public void mouseEntered(MouseEvent event){
System.out.println(“Mouse Enter”);}public void mouseExited(MouseEvent event){
System.out.println(“Mouse Exit”);}public void mousePressed(MouseEvent event){ }public void mouseClicked(MouseEvent event){ }
public void mouseReleased(MouseEvent event){ }}
AWT – Ejemplo de Interfaces Listener
El “listener” (applet) se registra con el botónEl botónoriginaeventoscon elmouse
import java.awt.*;import java.awt.event.*;import java.applet.Applet;
public class BotonTest2 extends Applet {public void init () {
Button boton = new Button(“Click”);boton.addMouseListener(new ButtonMouseListener());add(boton);
}
public ButtonMouseListener extends MouseAdapter {public void mouseEntered(MouseEvent event){ System.out.println(“Mouse Enter”);}public void mouseExited(MouseEvent event){ System.out.println(“Mouse Exit”);}
}
AWT - Ejemplo de Clases Adapters
La claseMouseAdapter,implementa la interfazMoudeListener
Claseinternasubclase deAdapter
}