Java Foundation Classes -JFC-

Transcripción

1 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 heavyweigth del AWT por componentes lightweigth. Java 2D: es un conjunto de clases que permiten manipular gráficos 2D avanzados e imágenes. Accesibility: consiste en un conjunto de clases que permiten a las componentes Swing 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 siguiente infraestructura: 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.

2 Abstract Window Toolkit -AWT- El AWT es un mundo de componentes de GUI. Aproximadamente la mitad de 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 de tamaño de las componentes dentro de un contenedor. Java provee varias clases que implementan estas interfaces. Clase Graphics: es una clase abstracta que define métodos para realizar operaciones gráficas sobre una componente (mostrar imágenes, texto, establecer colores y fonts). Toda componente AWT tiene asociado un objeto Graphics donde dibujarse.

3 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 objetos Component y Container: los containers pueden contener components. Todos los containers tienen asociado un layout manager (excepto la clase java.awt.container) que establece la ubicación y la forma de las componentes del Container. Las responsabilidades del layout manager las definen las interfaces java.awt.layoutmanager y java.awt.layoutmanager2.

4 Componentes AWT La clase java.awt.component es una clase abstracta que provee una amplia funcionalidad, heredada por todas sus subclases. Los controles de la interfaz de usuario como botones, scrollbars, labels, text, fields, etc. son subclase de java.awt.component. Cada componente AWT tiene asociada la 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

5 Componentes AWT estándares Panel Canvas Button TextField TextArea ScrollPane List Choice Checkbox Label ScrollBar

6 Componentes AWT y Peers El AWT original (versión 1.0) basó el diseño de sus componentes de GUI en peers. Los peers son componentes de GUI nativas (del sistema donde se ejecutan) manipuladas por componentes AWT. Las clases AWT encapsulan a los peers. Las componentes AWT estándares delegan en los peers la mayor parte de su funcionalidad.

7 Componentes AWT y Peers Cada componente AWT tiene una componente peer (nativa) equivalente. Ejemplo: cuando se usa el AWT para crear una instancia de la clase Menu, la JVM crea una instancia de un menu peer. Es el peer el que hace el trabajo real de desplegarse y manejar el comportamiento del menú. En este caso, el JDK de Solaris creará un objeto menú peer Motif; el JDK de Windows 95 creará menú peer Windows 95; el JDK de Macintosh creará menú peer Macintosh, etc. Programa Java Java AWT Sistema de Ventanas Nativo, Peers Presentación Windows 95 MAC Motif El programa JAVA crea y despliega una componente AWT, quien a su vez crea y despliega una componentes nativa -peer-.

8 Componentes AWT y Peers Ventajas y desventajas del diseño basado en peers: Ventajas Evita reimplementar la funcionalidad provista por las componentes nativas de GUI. Retiene el look and feel de la plataforma donde se ejecuta el applet ó la aplicación. Desventajas El diseño basado en peers no es escalable.

9 Componentes AWT Heavyweigth 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) implicaba extender la clase java.awt.canvas (ó java.awt.container para implementar un contener). No se podían extender java.awt.component ni java.awt.container. Estas clases solamente podían ser subclaseadas por clases del paquete java.awt ya que sus constructores tenían alcance de paquete.

10 Componentes AWT Lightweigth El AWT 1.1 introduce componentes de GUI lightweigth: No están basadas en peers. Se pintan en la ventana de su contenedor heavyweigth (en el objeto graphic del contenedor). Tienen forma inorgánica y son transparentes. Se implementan extendiendo las clases java.awt.component ó java.awt.container. Las componentes lightweigth necesitan un contenedor heavyweigth donde dibujarse (por eso son transparentes). Esto no es un inconveniente ya que las componentes residen en un Applet ó en un Frame que son contenedores heavyweigth (en el caso de aplicaciones).

11 Componentes AWT Lightweigth La manipulación de las componentes lightweigth es igual a la de las heavyweigth. Esto es, se establece la posición, se agregan a los contenedores, se pintan, etc.. Las componentes lightweigth NO tienen un objeto gráfico propio donde pintarse. Los contenedores lightweigth NO tienen layout manager preestablecido. Es necesario establecer un layout manager ó ubicar en forma manual cada una de sus componentes. Las componentes Swing provistas en el JDK 1.2 son lightweigth y reemplazan a las componentes AWT heavyweigth. Además proveen componentes de GUI adicionales como tablas, árboles, cajas de diálogo.

12 Pintar componentes en AWT En AWT las componentes se pintan de acuerdo a un: Requerimiento del sistema: El sistema le pide a la componente que despliegue su contenido, usualmente porque la componente es la primera vez que se muestra en la pantalla ó cambia de tamaño ó necesita ser reparada (por ej. un objeto que antes la tapaba parcialmente se movió). Requerimiento de la aplicación: La componente decide que necesita actualizar su contenido debido a que su estado interno cambió (por ej. al presionar un botón mostrarlo con apariencia de hundido).

13 Pintar componentes en AWT AWT usa un mecanismo de callback para pintar las componentes. Esto significa que el programa debe sobreescribir un método particular ubicando allí el código para pintar y el AWT se encarga de invocar este método en el momento preciso (cuando se necesita pintar la componente). Este mecanismo es similar para las componentes heavyweigth 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 el estado apropiado: color, fonts, área que necesita ser reparada

14 Pintar componentes en AWT No es recomendado desde un programa invocar directamente 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 un requerimiento explícito de pintado en forma asincrónica. El método repaint() causa que TODA la componente se pinte. Los métodos repaint con argumentos permiten definir la región que necesita repararse.

15 Requerimiento de pintado de componentes Originado desde el sistema El AWT determina que toda ó parte de una componente necesita ser pintada. El AWT causa un PaintEvent El AWT causa que un thread invoque al método paint() sobre la componente Si la componente heavyweigth necesita actualizarse continuamente (por ej. una animación ), el método update() debe sobreescribirse para invocar sólo al paint(). Eliminando el borrado de la componente, se reduce el papadeo Originado desde una aplicación El programa determina que toda ó parte de una componente necesita volver a pintarse in respuesta a un cambio de estado interno. El programa invoca al método repaint() sobre la componente. Esto causa que se registre un pedido asincrónico al AWT para que se vuelva a pintar la componente. El AWT causa que un thread invoque al método update() sobre la componente. Si la componente no sobreescribe el método update(), la implementación por defecto limpia el background de la componente e invoca al método paint().

16 Requerimiento de pintado de componentes Si la componente es lightweigth, cuando el contenedor padre pinta su ventana, debe propagar la invocación al método paint() sobre todos sus descencientes lightweigth visibles. El método paint() de java.awt.container (definido en AWT 1.1), es el encargado de invocar al método paint() sobre todos sus componentes lightweigth visibles. Es fundamental que toda subclase de Container (lightweigth ó heavyweigth) que sobreescriba el método paint() invoque al super.paint() para asegurar que sus componentes lightweigth se pinten. En otro caso, las componentes ligthweigth no se ven.

17 Paquetes del AWT Paquetes AWT java.awt java.awt.event java.awt.datatransfer java.awt.image java.awt.accessibility java.awt.color java.awt.dnd java.awt.font java.awt.geom java.awt.im java.awt.peer java.awt.print funcionalidad de las componentes básicas de GUI clases de eventos e interfaces listeners soporte para clipboard y transferencia de datos clases para manipulación de imágenes tecnologías para asistir al usuario manejo de colores soporte de drag and drop fonts 2D geometría 2D métodos input interfaces peers para componentes peers soporte de impresión Descripción

18 AWT - Containers La clase java.awt.container es una clase abstracta, subclase de java.awt.component. Los objetos Container son simplemente componentes AWT que pueden contener otras componentes. Todo objeto Container tiene una referencia a un objeto LayoutManager, que es el responsable de ubicar y distribuir las componentes. Cada vez que ocurre un evento que provoca que el contenedor tenga que acomodar sus componentes (por ej. cambió el tamaño de la ventana), el layout manager del contenedor es invocado para reacomodar las componentes. Diferentes layout managers implementan diferentes algoritmos para reubicar componentes. La clase Applet es subclase de Panel, que a su vez es subclase de Container, por lo tanto las applets heredan toda la capacidad de contener y acomodar componentes sobre la pantalla. Así se simplifica el diseño de las applets.

19 AWT - Containers Subclases Descripción Applet Dialog FileDialog Frame Panel ScrollPane Window Es subclase de Panel. Es la superclase de todas las applets. Es subclase de Window. Puede ser modal o no-modal. Es un Dialog para elegir archivos. Es subclase de Window. Es el contenedor de las aplicaciones. Puede contener un menubar. Es un simple contenedor. Permite hacer Scroll de una componente. No tiene menubar ni borde. Es la superclase de Frame y Dialog.

20 AWT - Layout Manager Los containers delegan en el layout manager todo lo relacionado a la ubicación, tamaño, espaciado y distribución de sus componentes en la pantalla. La interfaz LayoutManager define métodos para calcular tamaños mínimos y preferidos de sus contenedores y ubicar las componentes en un contenedor. Un contenedor tiene exactamente un Layout Manager y un Layout Manager resuelve el trabajo de más de un contenedor. El AWT define cinco clases que implementan las interfaces LayoutManager o LayoutManager2 (son los layouts que establecen restricciones sobre las componentes): BorderLayout, CardLayout, FlowLayout, GridBagLayout y GridLayout

21 AWT - Layout Manager BorderLayout CardLayout FlowLayout: GridBagLayout GridLayout Es el layout por defecto de objetos Window. Establece restricciones especificadas mediante strings sobre las componentes : North, South, East, West, Center. Además es posible especificar el espaciado entre las componentes. Es usado para contener en una misma área diferentes componentes en momentos diferentes. Frecuentemente es controlado por un objeto Choice. Es el layout por defecto de objetos Panel. Ubica las componentes de izquierda a derecha, usando nuevas filas si es necesario. Es posible alinear las componentes y establecer el espaciado entre las componentes. Es el layout más sofisticado y flexible. Ubica las componentes en una grilla de filas y columnas, permitiendo que algunas componentes usen más de una celda. No todas las filas tienen la misma altura, ni todas las columnas el mismo ancho. Ubica las componentes en una grilla de celdas de igual tamaño.

22 AWT - FlowLayout Es el layout manager por defecto de Panel. El FlowLayout acomoda las componentes del container en una fila, centradas y con su tamaño preferido. Si el espacio horizontal del container no es suficiente para ubicar a todas las componentes en una fila, el FlowLayout utiliza 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 espaciado horizontal 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 ));

23 AWT - BorderLayout Es el layout manager por defecto de Window (Dialog y Frame). El BorderLayout usa cinco áreas para acomodar las componentes del container: North, South, East, West y Center. Al agrandar la ventana, el área central es la que ocupará la mayor parte del espacio disponible, las restantes áreas se expanden solamente lo necesario como para completar el espacio. Por defecto, 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 ));

24 AWT - Ejemplo public class UIDemo extends Applet { Button b1,b2; Checkbox c1; Label l1; Container 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); Agrega las componentes de la GUI al applet add(c1); add(l1); } }

25 Manejo de Eventos en AWT 1.1 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 del AWT 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 del evento y objetos que escuchan y atienden esos eventos llamados listeners del evento. Los objetos que disparán eventos son las componentes de GUI (fuentes generadoras de eventos) y, delegan el manejo de los mismos a los objetos listeners. Los objetos listeners son registrados sobre las componentes invocando al método: addxyzlistenter(xyzlistener). Luego de la registración, los métodos apropiados del listener serán invocados cuando el tipo de evento correspondiente ocurra sobre la componente.

26 Manejo de Eventos en AWT 1.1 Las componentes que generan eventos implementan un método para la registración de listeners (por ej. Button.addActionListener(ActionListener) y Button.removeActionListener(ActionListener)). De esta manera, los objetos 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 evento apropiado que es pasado al/los listeners que se registraron sobre la componente. Los listeners son los responsables de implementar métodos para el manejo de eventos. Estos métodos tienen como parámetro un objeto evento que contiene información acerca del evento y al objeto que originó el evento. 3) Se instancia un evento de un tipo apropiado (event) 2) Ocurre un Evento Fuente de Eventos 4) listener.eventhandler(event) Listener de Eventos 1) fuente.addlistenertype(new ListenerType())

27 AWT - Clases de Eventos 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. EventObject Objeto que generó el evento AWTEvent A Eventos para activar, desactivar, cerrar, abrir, minimizar y maximizar ventanas. ActionEvent AdjustmentEvent CompomentEvent ItemEvent TextEvent ContainerEvent FocusEvent InputEvent PaintEvent WindowEvent A MOUSE_CLICKED MOUSE_ENTERED MOUSE_EXITED MOUSE_PRESSED MOUSE_RELEASED... MouseEvent KeyEvent WINDOW_ACTIVATED WINDOW_DEACTIVATED WINDOW_OPENED WINDOW_CLOSED WINDOW_ICONIFIED

28 AWT - Interfaces EventListener Las interfaces EventListener residen en los paquetes java.util y java.awt.event EventListener AdjustmentL istener Window- Listener MouseMotion- Listener Action- Listener actionperformed(actionevent) Component- Listener Focus- Listener Container- Listener Text- Listener Item- Listener KeyListener textvaluechanged(textevent) Mouse-Listener mouseclicked(mouseevent) mouseentered(mouseevent) mouseexited(mouseevent) mousepressed(mouseevent) mousereleased(mouseevent)

29 AWT - Interfaces EventListener 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án invocados cuando ocurre un evento específico. Por ejemplo, la interfaz ActionListener define un método actionperformed() que es invocado cuando un evento action es disparado por una componente (por ej. un botón). Los listeners asociados a una componente son los encargados de interceptar y atender los eventos generados por la componente para los que el listener registró interés.

30 import java.awt.*; import java.awt.event.*; import java.applet.applet; public class BotonTest extends Applet implements MouseListener { El botón origina eventos con el mouse } 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){ } AWT Ejemplo de Interfaces Listener System.out.println( Mouse Exit ); public void mousepressed(mouseevent event){ } public void mouseclicked(mouseevent event){ } public void mousereleased(mouseevent event){ } El listener (applet) se registra con el botón

31 Clase interna subclase de Adapter AWT - Ejemplo de Clases Adapters 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 ); La clase MouseAdapter, implementa la interfaz MoudeListener