Unidad I Eventos

Modelo de Delegación de Eventos

 De acuerdo con Javasoft, las principales características de partida que han originado el nuevo modelo de manejo de eventos en el AWT, son:

  • Que sea simple y fácil de aprender
  • Que soporte una clara separación entre el código de la aplicación y el código del interfaz
  • Que facilite la creación de robustos controladores de eventos, con menos posibilidad de generación de errores (chequeo más potente en tiempo de compilación)
  • Suficientemente flexible para permitir el flujo y propagación de eventos
  • Para herramientas visuales, permitir en tiempo de ejecución ver cómo se generan estos eventos y quien lo hace
  • Que soporte compatibilidad binaria con el modelo anterior

Los eventos ahora están organizados en jerarquías de clases de eventos.

El nuevo modelo hace uso de fuentes de eventos (Source) y receptores de eventos (Listener). Una fuente de eventos es un objeto que tiene la capacidad de detectar eventos y notificar a los receptores de eventos que se han producido esos eventos. Aunque el programador puede establecer el entorno en que se producen esas notificaciones, siempre hay un escenario por defecto.

Un objeto receptor de eventos es una clase (o una subclase de una clase) que implementa un interfaz receptor específico. Hay definidos un determinado número de interfaces receptores, donde cada interfaz declara los métodos adecuados al tratamiento de los eventos de su clase. Luego, hay un emparejamiento natural entre clases de eventos y definiciones de interfaces. Por ejemplo, hay una clase de eventos de ratón que incluye muchos de los eventos asociados con las acciones del ratón, y hay un interfaz que se utiliza para definir los receptores de esos eventos.

Un objeto receptor puede estar registrado con un objeto fuente para ser notificado de la ocurrencia de todos los eventos de la clase para los que el objeto receptor está diseñado. Una vez que el objeto receptor está registrado para ser notificado de esos eventos, el suceso de un evento en esta clase automáticamente invocará al método sobreescrito del objeto receptor. El código en el método sobreescrito debe estar diseñado por el programador para realizar las acciones específicas que desee cuando suceda el evento.

Algunas clases de eventos, como los de ratón, involucran a un determinado conjunto de eventos diferentes. Una clase receptor que implemente el interfaz que recoja estos eventos debe sobreescribir todos los métodos declarados en el interfaz. Para prevenir esto, de forma que no sea tan tedioso y no haya que sobreescribir métodos que no se van a utilizar, se han definido un conjunto de clases intermedias, conocida como clases Adaptadoras (Adapter).

Estas clases Adaptadores implementan los interfaces receptor y sobreescriben todos los métodos del interfaz con métodos vacíos. Una clase receptor puede estar definida como clase que extiende una clase Adapter en lugar de una clase que implemente el interfaz. Cuando se hace esto, la clase receptor solamente necesita sobreescribir aquellos métodos que sean de interés para la aplicación, porque todos los otros métodos serán resueltos por la clase Adapter

Uno de los objetos receptor que se implementan con mayor frecuencia son los de la interfaz WindowListener en el manejo de ventanas, lo que haria necesario sobreescribir los seis métodos de la interfaz.  Por lo que la otra clase receptor que se extiende es la clase WindowAdapter en vez de implementar la interfaz WindowListener.   La clase WindowAdapter sobrescribe los seis métodos de la interfaz con métodos vacíos, por lo que la clase receptor no necesita sobreescribir esos seis métodos solo el que necesita.

 

Gestión de Eventos

El paquete java.awt.event es el que contiene la mayor parte de las clases e interfaces de eventos.  El modelo de delegación de eventos es un concepto que trabaja de la siguiente manera: 

Una fuente genera un evento y lo envía a uno a más oyentes o auditores, que han estado simplemente esperando hasta que reciben ese evento y una vez recibido lo procesan y lo devuelven.

 

Una fuente es un objeto que genera un evento. Esto ocurre cuando cambia de alguna manera el estado interno de ese objeto. Las fuentes pueden generar más de un tipo de eventos.

 

Una fuente tiene que ir acompañada de auditores para que estos reciban las notificaciones sobre el tipo específico de evento, cada tipo de evento tiene su propio método de registro. La forma general es:

Public void addTypeListener(TypeListener el)

 

Por ejemplo el método que registra o acompaña a un auditor de evento de teclado es addKeyListener( ). Cuando ocurre un evento, se notifica a todos los auditores registrados, que reciben una copia del objeto evento. Esto es lo que se conoce como multicasting del evento.

Una fuente también puede proporcionar un método que permita a un auditor eliminar un registro en un tipo específico de evento y la forma general es:

Public void removeTypeListener(TypeListener el);

 

Aquí Type es el nombre del evento y el es una referencia al auditor. Por ejemplo para borrar un auditor del teclado se llamaría removeKeyListener( ).

 

Auditores de eventos.

Un auditor es un objeto que es avisado cuando ocurre un evento. Tiene dos requisitos principales. Primero tiene que ser registrado o ir acompañado por una o más fuentes para recibir notificaciones sobre los tipos específicos de eventos. Segundo, tiene que implementar métodos para recibir y procesar notificaciones.

 

 

Clases de eventos principales en java.awt.event

Clase de evento

Descripción

ActionEvent

Se genera cuando se presiona un botón, se hace doble clic en un elemento de una lista, o se selecciona un elemento de tipo menú.

AdjustmentEvent

Se genera cuando se manipula un scrollbar.

ComponentEvent

Se genera cuando un componente se oculta, se mueve, se cambia de tamaño o se hace visible.

ContainerEvent

Se genera cuando se añade o se elimina un componente de un contenedor.

FocusEvent

Se genera cuando un componente gana o pierde el foco.

InputEvent

Superclase abstracta de cualquier clase de evento de entrada de componente.

ItemEvent

Se genera cuando se hace click en un checkbox o en un elemento de una lista; tambien ocurre  cuando se hace una selección en una opción choice o cuando se selecciona o deselecciona un elemento de un menú de opciones.

KeyEvent

Se genera cuando se recibe una entrada desde el teclado.

MouseEvent

Se genera cuando el ratón se arrastra, se mueve, se hace clic, se presiona, o se libera; también se genera cuando el ratón entra o sale de un componente.

TextEvent

Se genera cuando se cambia el valor de un área de texto o un campo de texto

WindowEvent

Se genera cuando una ventana se activa, se cierra, se desactiva, se minimiza, se maximiza, se abre, o se sale de ella.

 

 

ActionEvent

Define cuatro constantes enteras que se pueden utilizar para identificar cualquier modificador asociado con este tipo de evento: ALT_MASK,CTRL_MASK,META_MASK,SHIFT_MASK  una última constante entera ACTION_PERFORMED que se utiliza para identificar eventos de acción.

 

Para identificar el evento de acción generado se utiliza el método String getActionCommand( )

getSource( ) devuelve el objeto del tipo que genero el evento.

Para identificar el tipo de tecla modificadora se uso se utiliza el método int getModifiers( )

 

AdjustmentEvent

En este tipo de evento hay cinco constantes enteras que definen la actividad realizada por este evento:

BLOCK_DECREMENT el usuario hace click dentro de la scrollbar para decrementar su valor.

BLOCK_INCREMENT el usuario hace click dentro de la scroll bar para incrementar su valor.

TRACK  se arrastra el botón movible de la scroll bar

UNIT_DECREMENT se ha hecho click en el botón que esta al final de la scroll bar para decrementar su valor

UNIT_INCREMENT se ha hecho click en el botón que esta al final de la scroll bar para incrementar su valor

 

Además hay una constante entera ADJUSTEMENT_VALUE_CHANGED que indica que ha ocurrido un cambio.

 

Para determinar el tipo de ajuste se realiza mediante el método

 int getAdjustmentType( )

 

Y la cantidad de ajuste se obtiene mediante int getValue( )

 

 

ItemEvent

Hay dos tipos de eventos de elemento y se identifican por las siguientes constantes enteras:

DESELECTED el usuario deselecciona un elemento

SELECTED el usuario selecciona un elemento

Además define una constante para indicar que ocurrió un cambio y es ITEM_STATE_CHANGED

Tambien define tres métodos unos es Object getItem( ) que devuelve la referencia al objeto que ha generado el evento

ItemSelectable getItemSelectable( ) que se usa para obtener una referencia a los objetos ItemSelectable que han generado un evento.

Int getStateChange( ) que devuelve el cambio de estado ocurrido ya se SELECTED o DESELECTED.

 

KeyEvent

Define tres constantes enteras y son KEY_PRESSED, KEY_RELEASED Y KEY_TYPED las dos primeras se generan cuando se presiona o se libera una tecla y el ultimo se genera cuando se genera un carácter.

 

Hay eventos que se generan que no siempre producen caracteres y es cuando se presionan teclas como el SHIFT y las constantes definidas son:

VK_0…VK_9 y VK_A….VK_Z

VK_ENTER,VK_ESCAPE,VK_CANCEL,VK_UP,VK_DOWN,VK_LEFT,VK_RIGHT, VK_PAGE_DOWN,VK_PAGE_UP,VK_SHIFT,VK_ALT,VK_CONTROL

VK especifica código de teclas virtuales y son independientes de SHIFT y ALT

En caso que no este definido el carácter generara un CHAR_UNDEFINED O VK_UNDEFINED

 

Los métodos que mas se usan son char getKeyChar( ) y int getKeyCode( )  respectivamente devuelve el carácter presionado y el tipo de  tecla presionada.

 

MouseEvent

Define las siguientes constantes para identificar los tipos de eventos y son:

MOUSE_CLICKED el usuario hace click con el ratón

MOUSE_DRAGGED el usuario arrastra el ratón

MOUSE_ENTERED el ratón mete un componente

MOUSE_EXITED el ratón sale de un componente

MOUSE_MOVED se mueve el ratón

MOUSE_PRESSED se presiona el ratón

MOUSE_RELEASED se libera el raton

Los métodos mas usados son: int getX( ), int getY( ) que devuelven las coordenadas x,y del ratón y o Point getPoint( ) que tambien las devuelve pero mediante un objeto de tipo Point

El método int getClickCount( ) que indica el número de clicks que se han hecho con el ratón

 

 

WindowEvent define las siguientes constantes:

WINDOW_ACTIVATED se ha activado la ventana

WINDOW_CLOSED se ha cerrado la ventana

WINDOW_CLOSING se ha pedido que se cierre la ventana

WINDOW_DEACTIVATED la ventana a dejado de estar activa

WINDOW_DEICONIFIED se ha mostrado la ventada tras pulsar su icono

WINDOW_ICONIFIED se ha minimizado la ventana

WINDOW_OPENED se ha abierto la ventana

La función que se utiliza es Window getWindow( ) que devuelve el objeto que ha generado el evento.

 

 

Fuentes de Eventos

 

Todas las fuentes de eventos del AWT soportan el multienvío a receptores. Esto significa que se pueden añadir o quitar múltiples receptores de una sola fuente; en otras palabras, la notificación de que se ha producido un mismo evento se puede enviar a uno o más objetos receptores simultáneamente.

El API de Java no garantiza el orden en que se enviarán los eventos a los receptores que están registrados en un objeto fuente, para ser informados de esos eventos. En caso de que el orden en que se distribuyen los eventos sea un factor importante en el programa, se deberían encadenar los receptores de un solo objeto receptor registrado sobre el objeto fuente; el hecho de que los datos del evento estén encapsulados en un solo objeto hace que la propagación del evento sea extremadamente simple.

Como en el caso de los receptores, se puede hacer una distinción entre los eventos de bajo nivel y los eventos de tipo semántico. Las fuentes de eventos de bajo nivel serán las clases de elementos o componentes visuales del interfaz gráfico (botones, barras de desplazamiento, cajas de selección, etc.), porque cada componente de la pantalla generará sus eventos específicos. El JDK 1.2 permite registrar receptores sobre fuentes de eventos de los siguientes tipos:

    java.awt.Component
      addComponentListener
      addFocusListener
      addKeyListener
      addMouseListener
      addMouseMotionListener
    java.awt.Container
      addContainerListener
    java.awt.Dialog
      addWindowListener
    java.awt.Frame
      addWindowListener

Para determinar todos los tipos de eventos que se pueden comunicar desde un objeto fuente a un receptor, hay que tener en cuenta la herencia. Por ejemplo, como se verá en uno de los programas que se presentarán, un objeto puede detectar eventos del ratón sobre un objeto Frame y notificar a un objeto MouseListener de la ocurrencia de estos eventos, aunque en la lista anterior no se muestre un MouseListener sobre un Frame. Esto es posible porque un objeto Frame extiende indirectamente la clase Component y, MouseListener está definida en la clase Component.

Los receptores de eventos que se pueden registrar de tipo semántico sobre objetos fuentes, generadores de eventos, en el JDK 1.2 son:

    java.awt.Button
      addActionListener
    java.awt.Choice
      addItemListener
    java.awt.Checkbox
      addItemListener
    java.awt.CheckboxMenuItem
      addItemListener
    java.awt.List
      addActionListener
      addItemListener
    java.awt.MenuItem
      addActionListener
    java.awt.Scrollbar
      addAdjustmentListener
    java.awt.TextArea
      addTextListener
    java.awt.TextField
      addActionListener

      addTextListener

 

Ejemplos de componentes que pueden generar eventos

Origen de evento

Descripción

Button

Genera eventos de acción (ActionEvent) cuando se presiona el botón.

Checkbox

Genera eventos de elementos (ItemEvent) cuando se selecciona o deselecciona un checkbox.

Choice

Genera eventos de elementos cuando se cambia de opción choice.

List

Genera eventos de acción cuando se hace doble click sobre un elemento, genera eventos de elemento cuando se selecciona o deselecciona un elemento.

Menu Item

Generá eventos de acción cuando se selecciona un elemento de menú; genera eventos de lemento cuando se selecciona o se deselecciona un elemento de un menú de opciones.

Scrollbar

Genera eventos de ajuste (AdjustmentEvent) cuando se manipula el scrollbar.

Text components

Genera eventos de texto (TextEvent) cuando el usuario introduce un carácter.

Window

Genera eventos de ventana (WindowEvent) cuando una ventana se activa, se cierra, se desactiva, se minimiza, se maximiza, se abre o se sale de ella.

 

Adaptadores

Muchos interfaces EventListener están diseñados para recibir múltiples clases de eventos, por ejemplo, el interfaz MouseListener puede recibir eventos de pulsación de botón, al soltar el botón, a la recepción del cursor, etc. El interfaz declara un método para cada uno de estos subtipos. Cuando se implementa un interfaz, es necesario redefinir todos los métodos que se declaran en ese interfaz, incluso aunque se haga con métodos vacíos. En la mayoría de las ocasiones, no es necesario redefinir todos los métodos declarados en el interfaz porque no son útiles para la aplicación.

Por ello, el AWT proporciona un conjunto de clases abstractas adaptadores (Adapter) que coinciden con las interfaces. Cada clase adaptador implementa un interfaz y redefine todos los métodos declarados por el interfaz con métodos vacíos, con lo cual se satisface ya el requerimiento de la redefinición de todos los métodos.

Se pueden definir clases Receptor extendiendo clases adaptadores, en vez de implementar el interfaz receptor correspondiente. Esto proporciona libertad al programador para redefinir solamente aquellos métodos del interfaz que intervienen en la aplicación que desarrolla.

De nuevo, hay que recordar que todos los métodos declarados en un interfaz corresponden a los tipos de eventos individuales de la clase de eventos correspondiente, y que el objeto Fuente notifica al Receptor la ocurrencia de un evento de un tipo determinado invocando al método redefinido del interfaz.

Las clases Adaptadores que se definen en el JDK 1.2 son las que se indican a continuación:

    java.awt.ComponentAdapter 
    java.awt.FocusAdapter 
    java.awt.KeyAdapter
    java.awt.MouseAdapter 
    java.awt.MouseMotionAdapter 
    java.awt.WindowAdapter 

 

 

Interfaces de auditor que más se utilizan

 

ActionListener

La interfaz tiene que definir el método:

void actionPerformed(ActionEvent e)  el cual se invoca cuando ocurre un evento de acción.

 

AdjustmentListener

La interfaz tiene que definir el método:

void adjustmentValueChanged(AdjustmetEvent ae) el cual se invoca cuando ocurre un evento de ajuste.

 

ComponentListener

La interfaz tiene que definir los siguientes métodos:

void componentResized(ComponentEvent ce)

void componentMoved(ComponentEvent ce)

void componentShown(ComponentEvent ce)

void componentHiden(ComponentEvent ce)

Se invocan cuando a un componente se le cambia de tamaño, se mueve, se muestra o se oculta.

 

 

ContainerListener   

La interfaz tiene que definir los siguientes métodos:

void componentAdded(ContainerEvet ce)

void componentRemoved(ContainerEvet ce)

Se invocan cuando se añade un componente a un contenedor y cuando se borra un componente de un contenedor.

 

FocusListener

La interfaz tiene que definir los siguientes métodos:

void focusGained(FocusEvent fe)

void focusLost(FocusEvent fe)

Se invocan cuando se gana el foco o se pierde el foco

ItemListener

La interfaz tiene que definir el siguiente método:

void itemStateChanged(ItemEvent ie)

Se invoca cuando cambia el estado de un elemento

 

KeyListener

La interfaz tiene que definir los siguientes métodos:

void keyPressed(KeyEvent ke)

void keyReleased(KeyEvent ke)

void keyTyped(KeyEvent ke)

Se invocan cuando se presiona, libera una tecla y cuando se introduce un carácter.

 

MouseListener

La interfaz tiene que definir los siguientes métodos:

void mouseClicked(MouseEvent me)

void mouseEntered(MouseEvent me)

void mouseExited(MouseEvent me)

void mousePressed(MouseEvent me)

void mouseReleased(MouseEvent me)

Se invocan cuando se presiona, cuando entra a un componente, cuando sale, cuando se presiona y se libera el ratón.

 

MouseMotionListener

La interfaz tiene que definir los siguientes métodos:

void mouseDragged(MouseEvent me)

void mouseMoved(MouseEvent me)

Se invocan cuando se arrastra y se mueve el ratón.

 

TextListener

La interfaz tiene que definir el siguiente método:

void textChanged(TextEvent te)

Se invoca cuando ha ocurrido un cambio en un área de texto o en un campo de texto.

 

WindowListener

La interfaz tiene que definir los siguientes métodos:

void windowActivated(WindowEvent we) activa

void windowDeactivated(WindowEvent we) desactiva

void windowClosed(WindowEvent we) cierra

void windowClosing(WindowEvent we) petición de cerrar

void windowDeiconfied(WindowEvent we)

void windowIconfied(WindowEvent we) minimiza

void windowOpened(WindowEvent we) abre

      Se invocan cuando se activa, se desactiva, se cierra una ventana, se esta cerrando una ventana, se minimiza a un icono, cuando se abre a partir de un icono y cuando se abre una ventana.

 

 

Clases adaptadoras que se usan cuando no se requieren definir todos los eventos de un elemento y son:

 

Clase Adaptadora

Interfaz auditora

ComponentAdapter

ComponentListen

ContainerAdapter

ContainerListen

FocusAdapter

FocusListener

KeyAdapter

KeyListener

MouseAdapter

MouseListener

MouseMotionAdapter

MouseMotionListener

WindowAdapter

WindowListener

 

 Applets

 

Los applets son aplicaciones que se pueden ejecutar sobre Internet, para construir un applet se debe construir una clase derivada la clase existente Applet.

 

Los applets deben de incluir dos paquetes que son:

 java.awt y java.applet

 

Los applets son ejecutados por un navegador de internet o bien por un visor de applets (appletviewer) y se deben de incluir en una página web como sigue:

 

<applet code=“miapplet” width=200 height=60>

</applet>

 

 

Estructura de un Applet

Import java.awt.*;

Import java.applet.*;

Public class esqueleto extends Applet{

Public void init(){

//código de inicialización

}

Public void start(){

// código que comienza y reanuda la ejecución

}

Public void stop(){ //código que detiene la ejecución

}

Public void destroy( ){ //se ejecuta cuando termina el applet ultimo}

Public void paint(Graphics g){ //código para dibujar el contenido de la ventana

}

}

 

 

Orden de ejecución de los  métodos en los applets

Cuando comienza un applet el AWT llama a los siguientes métodos:

 

init()  start() y paint()

 

Cuando finaliza un applet se llama a los siguientes métodos.

 

stop()   destroy()

 

init es el primer método y es cuando se deberían de inicializar las variables.

 

start se llama inmediatamente despues del init es llamado para reanudar un applet después de que este se haya detenido o parado. Este se llama cada vez que un documento HTML de un applet se visualiza en la pantalla.

 

paint se le llama cada vez que la salida del applet tiene que redibujarse y tambien se llama cuando el applet empieza a ejecutarse o miestras el applet tenga que dibujar una salida.

 

stop se llama cuando el navegador deja el documento HTML que contiene el applet, cuando se va a otra pagina

 

destroy se llama cuando determina que ya acabo el applet

 

 

Ejemplo de un applet

import java.awt.*;

import java.applet.*;

public class app extends Applet{

            String msg;

            public void init()

            {

                        setBackground(Color.blue);    //establecer el color del fondo

                        setForeground(Color.white);   //establecer el color de la fuente

                        msg="en el init   ";

            }

            public void start(){

                        msg+="dentro de start   ";

            }

            public void paint(Graphics g){

                        msg+="en el interior del paint";

                        g.drawString(msg,10,30);

            }

}

 

 

Programa HTML

<html>

 <head>

<title>Primer applet</title>

<applet code=“app.class” width=300 height=200>

</applet>

</head>

 <body> 

<b>corriendo</b>

</body>

</html>

 

Trabajo con graficos.

 El AWT tiene una amplia variedad de métodos graficos graficos. Todos los gráficos se dibujan en una ventana, que puede ser una ventana principal de un applet, una ventana hija de un applet, o una ventana de una aplicación independiente.

 El origen (0,0) de cada ventana está en la esquina superior izquierda. Las coordenadas vienen en pixeles.  Todas las salidas sobre una ventana tienen lugar a traves de un contexto gráfico.  Un contexto grafico está encapsulado en la clase Graphics y se obtiene de 2 maneras:

 ·         Se pasa a un applet cuando se llama a algunos de sus métodos, como paint( ) o update( ).

·         Es devuelto por el método getGraphics( ) de Component

 Líneas de dibujo.

 Las líneas se dibujan con el método drawLine(int x,int y,int x1,int y1) que realiza una linea con el color en uso.

 Dibujar rectángulos.

 Los métodos drawRect( ) y fillRect dibujan un rectángulo sólo con el borde o relleno, respectivamente.

 void drawRect(int x,int y,int anchox,int largoy)

void fillRect(int x,int y, int anchox,int largoy)

 Para dibujar un rectángulo redondeado, se usan los métodos drawRoundRect(int x,int y, int anchox,int largoy,int xdiam,int ydiam) o fillRoundRect(int x,int y, int anchox,int largoy,int xdiam,int ydiam).   El diámetro del arco a lo largo del eje x y eje y estan dados por xdiam,ydiam.

Dibujar círculos y elipses.

Para dibujar una elipse se utiliza el método drawOval(int x,int y,int anchox, int largoy) y para una elipse rellena se utiliza el método fillOval(int x,int y,int anchox, int largoy)

 Dibujar arcos.

Los arcos se pueden dibujar con drawArc(int x,int y, int anchox,int altoy,int anguloinicial, int angulofinal) y fillArc(int x,int y, int anchox,int altoy,int anguloinicial, int angulofinal);

 Dibujar polígonos.

También se pueden dibujar figuras con formas arbitrarias utilizando los métodos drawPolygon(int x[ ],int y[ ],int numpuntos) y fillPolygon(int x[ ],int y[ ],int numpuntos).

 Los vértices del poligono estan especificados por las parejas de coordenadas que vienen en los arreglos x y y.

 Tamaño de los graficos.

Para obtener las dimensiones de la ventana se obtienen mediante getSize( ) este devuelve un objeto de la clase Dimension con las diemsiones de la ventana.

 Trabajar con color.

 El sistema de color del AWT permite especificar cualquier color. Para ello se busca el color que más se ajuste al solicitado, teniendo en cuenta las limitaciones del hardware de visualización (monitor,etc) en el que se esta ejecutando el programa o el applet.   El color esta encapsulado en la clase Color. 

La clase Color define varias consantes por ejemplo Color.black esto para especificar un conjunto de colores comunes.  Tambien puede crear sus propios colores utilizando uno de los constructores de colores. Las formas que mas se usan son las siguientes:

Color(int red,int green,int blue)

Color(int rgbValue)

Color(flota red,flota green,flota blue)

 Para establecer el color para los gráficos.

Por defecto, los objetos graficos se dibujan en el color actual del frente. Se puede cambiar este color llamando al método setColor(Color nuevocolor) y se puede obtener el color en curso llamando a Color getColor( )

 Establecer el modo de pintar.

El modo de pintar determina como se dibujan los objetos en una ventana. Por defecto, cada nueva salida que se realiza a una ventana se superpone al contenido de lo que hubiese en la anterior.  Sin embargo, es posible tener sobre la ventana nuevos objetos en modo XOR utilizando el método setXORMode( ), que tiene el formato siguiente:

                  void setXORMode(Color xorColor) 

donde xorColor especifica el color que se utilizara para hacer el XOR en la ventana cuando se dibuja un objeto.  La ventaja de modo XOR es que se garantiza que el nuevo objeto siempre sea visible, cualquiera que sea el color sobre el que se dibujara el objeto y para volver al modo de sobrescribir, hay que llamar a setPaintMode( ).

 Trabajo con los tipos de letra.

 Determinación de los tipos de letra disponibles.

Cuando se trabajan con tipos de letra suele ser necesario saber que tipos de letra están disponibles en la computadora. Para obtener esta información, se utiliza el método getAviableFontFamilyNames( ) definido por la clase GraphicsEnvironment:

 String[ ] getAviableFontFamilyNames( )

 Este método devuelve un array de strings con los nombres de las familias de tipos de letra disponibles.

 Ademas del método getAllFonts( ) está definido por la clase GraphicsEnvironment:

 Font[ ] getAllFonts( )

 Este método devuelve un arreglo de objetos Font que contiene todos los tipos de letras disponibles.

 Como estos métodos son miembros de GraphicsEnvironment, se necesita una referencia GraphicsEnvironment para llamarlos. Se puede obtener esa referencia utilizando el método estático getLocalGraphicsEnvironment( ), que está definido por GraphicsEnvironment:

 static GraphicsEnvironment getLocalGraphicsEnvironment( )

 Creación y selección del tipo de letra

 Para seleccionar un nuevo tipo de letra, primero hay que construir un objeto Font que describa ese tipo de letra.   Una de las formas del constructor Font tiene el siguiente formato:

 Font(String fontName,int fontStyle,int pointSize)

 fontName especifica el nombre del tipo de letra deseado.  Se puede especificar el nombre utilizado bien el nombre lógico, bien el nombre face.  Java admite los siguientes tipos de letra: Dialog, DialogInput, Sans Serif, Serif, Monospaced y Symbol. Dialog es el tipo de letra que utilizan las cajas de diálogo del sistema, tambien es el tipo de letra que hay por defecto.

 El estilo del tipo de letra se especifica con fontStyle y puede estar formado por una o mas de una de estas tres constantes: Font.PLAIN, Font.BOLD y Font.ITALIC.  Para combinar estilos se puede hacer un OR. Por ejemplo, Font.BOLD | Font.ITALIC especifica un estilo en negrita y cursiva.   El tamaño del tipo de letra, en puntos, se especifica en pointSize. Para utilizar un tipo de letra propio, se utiliza el método setFont( ), que esta definido por Component, y tiene la siguiente forma general:

 void setFont(Font fontObj)  

 donde fontObj es el objeto que contiene el tipo de letra deseado.

 

Visualización de varias lineas de texto.

Lo que más se utiliza es FontMetrics para determinar el espacio entre líneas de texto y tambien para determinar la longitud de un string que se esta visualizando.

 Para determinar el espacio entre lineas, se puede utilizar el valor devuelto por getLeading( ) y para determinar la altura total del tipo de letra, hay que sumar al valor devuelto por getAscent( )el valor devuelto por getDescent( ).   Otra forma de determinar la altura maxima del tipo de letra es utilizando getHeight( ) y para determinar la longitud en pixeles de una cadena se obtienen con stringWidth( ).    Ver ejercicio y centrar texto.

Ejemplo de manejo de primitivas de java usando AWT

import java.applet.*;

import java.awt.*;

public class primitivas extends Applet{

            public void init(){

                        setBackground(Color.BLUE);

                        setForeground(Color.WHITE);

                       

            }

            public void paint(Graphics g){

                        showStatus("uso de primitivas");

                        g.drawString("Inicio de las primitivas de java",10,20);

                        g.setColor(Color.GREEN);

                        g.drawLine(10,10,100,100);

                        g.drawRect(200,200,250,250);

                        g.fillRect(100,100,170,180);

                        g.drawRoundRect(300,300,50,50,10,10);

                        g.setColor(Color.green);

                        g.drawOval(20,20,50,50);

                        g.fillOval(50,50,50,50);

                        g.drawArc(400,300,50,50,0,360);

                        g.fillArc(400,300,50,50,0,45);

                        int cx[]={500,600,550};

                        int cy[]={200,200,100};

                        int cx1[]={500,600,550};

                        int cy1[]={400,400,300};

                        g.drawPolygon(cx,cy,3);

                        g.fillPolygon(cx1,cy1,3);

                        Dimension d;

                        d=getSize();

                        int x=d.width;

                        int y=d.height;

                        String xs=x+" "+y;

                        g.drawString(xs,100,100);

        }

}

Ejemplo de manejo de letras de java usando AWT

 import java.awt.*;

import java.applet.*;

public class letras extends Applet{

            Font f=new Font("Dialog",Font.PLAIN|Font.ITALIC,12);

            public void init(){

                        setFont(f);

            }

            public void paint(Graphics g){

                        setForeground(Color.BLUE);

                        g.drawString("cadenas de texto",10,10);

           

            }

}

  

import java.awt.*;

import java.applet.*;

public class tipofont extends Applet{

            public void paint(Graphics g){

                        GraphicsEnvironment ge=GraphicsEnvironment.getLocalGraphicsEnvironment();

                       

                        String msg[]=new String[60];

                        String Fontlist[];

                        Font fuentes[];

                        Fontlist=ge.getAvailableFontFamilyNames();

                        fuentes=ge.getAllFonts();

                        for(int i=0;i<msg.length;i++){

                                               msg[i]=fuentes[i]+" ";

                        }

                        for(int j=3;j<msg.length;j++)

                                   g.drawString(msg[j],10,j*11);                

            }

           

}

 

Gestores de Organización.

FlowLayout es el gestor de organización por defecto y utilizado en los ejemplos anteriores. Organiza de izquierda a derecha y de arriba abajo por default.

FlowLayout( )

FlowLayout( int how) 

How puede ser FlowLayout.LEFT, FlowLayout.CENTER, FlowLayout.RIGHT

FlowLayout( int how, int horz, int vert) los ultimos especifican el espacio entre elementos horizontales y verticales.

 

BorderLayout es la segunda forma de organización habitual por áreas, norte, sur, este, oeste, centro

BorderLayout( )

BorderLayout( int horiz,int vert) igual define espacios

Constantes que especifican las regiones:

BorderLayout.CENTER

BorderLayout.EAST

BorderLayout.NORTH

BorderLayout.SOUTH

BorderLayout.WEST

 

La forma de aplicar las organización es add(componente,region)

 GridLayout Organiza los componentes en una cuadricula de 2 dimensiones

GridLayout( )

GridLayout(int numfilas, int numcolumnas )

GridLayout(int numfilas, int numcolumnas,int hor,int vert )


AWT

AWT es el acrónimo del X Window Toolkit para Java, donde X puede ser cualquier cosa: Abstract, Alternative, Awkward, Another o Asqueroso; aunque parece que Sun se decanta por Abstracto, seriedad por encima de todo. Se trata de una biblioteca de clases Java para el desarrollo de Interfaces de Usuario Gráficas. La versión del AWT que Sun proporciona con el JDK se desarrolló en sólo dos meses y es la parte más débil de todo lo que representa Java como lenguaje. El entorno que ofrece es demasiado simple, no se han tenido en cuenta las ideas de entornos gráficos novedosos. Quizá la presión de tener que lanzar algo al mercado haya tenido mucho que ver en la pobreza de AWT.

Javasoft, en vista de la precariedad de que hace gala el AWT, y para asegurarse que los elementos que desarrolla para generar interfaces gráficas sean fácilmente transportables entre plataformas, se ha unido con Netscape, IBM y Lighthouse Design para crear un conjunto de clases que proporcionen una sensación visual agradable y sean más fáciles de utilizar por el programador. Esta colección de clases son las Java Foundation Classes (JFC), que están constituidas por cinco grupos de clases, al menos en este momento: AWT, Java 2D, Accesibilidad, Arrastrar y Soltar y Swing.

AWT, engloba a todos los componentes del AWT que existían en la versión 1.1.2 del JDK y en los que se han incorporado en versiones posteriores:

  • Java 2D es un conjunto de clases gráficas bajo licencia de IBM/Taligent, que todavía está en construcción
  • Accesibilidad, proporciona clases para facilitar el uso de ordenadores y tecnología informática a disminuidos, como lupas de pantalla, y cosas así
  • Arrastrar y Soltar (Drag and Drop), son clases en las que se soporta Glasgow, que es la nueva generación de los JavaBeans
  • Swing, es la parte más importante y la que más desarrollada se encuentra. Ha sido creada en conjunción con Netscape y proporciona una serie de componentes muy bien descritos y especificados de forma que su presentación visual es independiente de la plataforma en que se ejecute el applet o la aplicación que utilice estas clases. Swing simplemente extiende el AWT añadiendo un conjunto de componentes, JComponents, y sus clases de soporte. Hay un conjunto de componentes de Swing que son análogos a los de AWT, y algunos de ellos participan de la arquitectura MVC (Modelo-Vista-Controlador), aunque Swing también proporciona otros widgets nuevos como árboles, pestañas, etc.

La estructura básica del AWT se basa en Componentes y Contenedores. Estos últimos contienen Componentes posicionados a su respecto y son Componentes a su vez, de forma que los eventos pueden tratarse tanto en Contenedores como en Componentes, corriendo por cuenta del programador (todavía no hay herramientas de composición visual) el encaje de todas las piezas, así como la seguridad de tratamiento de los eventos adecuados. Con Swing se va un paso más allá, ya que todos los JComponentes son subclases de Container, lo que hace posible que widgets Swing puedan contener otros componentes, tanto de AWT como de Swing, lo que hace prever interesantes posibilidades.

A continuación se aborda la programación con el AWT fundamentalmente para tener la base suficiente y poder seguir profundizando en las demás características del lenguaje Java, aunque también se presentarán ejemplos de utilización de JComponentes cuando Swing tenga implementado alguno que corresponda el del AWT o derivado de él.

Estructura del AWT

La estructura de la versión actual del AWT se puede resumir en los puntos que se exponen a continuación:

  • Los Contenedores contienen Componentes, que son los controles básicos
  • No se usan posiciones fijas de los Componentes, sino que están situados a través de una disposición controlada (layouts)
  • El común denominador de más bajo nivel se acerca al teclado, ratón y manejo de eventos
  • Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación (no hay áreas cliente, ni llamadas a X, ni hWnds, etc.)
  • La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de tener un tamaño fijo
  • Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede asumir que un diálogo tendrá el mismo tamaño en cada máquina)
  • Carece de un formato de recursos. No se puede separar el código de lo que es propiamente interface. No hay ningún diseñador de interfaces (todavía)

Componentes y Contenedores

Una interfaz gráfica está construida en base a elementos gráficos básicos, los Componentes. Típicos ejemplos de estos Componentes son los botones, barras de desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa. En el AWT, todos los Componentes de la interface de usuario son instancias de la clase Component o uno de sus subtipos.

Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situación de los Componentes; además, los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación. En el AWT, todos los Contenedores son instancias de la clase Container o uno de sus subtipos.

Tipos de Componentes

En el árbol siguiente se muestra la relación que existe entre todas las clases que proporciona AWT para la creación de interfaces de usuario, presentando la jerarquía de Clases e Interfaces:

Clases:

  • Adjustable
  • BorderLayout
  • CardLayout
  • CheckboxGroup
  • Color
  • Component
    • Button
    • Canvas
    • Checkbox
    • Choice
    • Container
    • Panel
      • Applet
    • ScrollPane
    • Window
      • Dialog
      • FileDialog
      • Frame
    • Label
    • List
    • Scrollbar
    • TextComponent
    • TextArea
    • TextField
  • Cursor
  • Dimension
  • Event
  • FlowLayout
  • Font
  • FontMetrics
  • Graphics
  • GridLayout
  • GridBagConstraints
  • GridBagLayout
  • Image
  • Insets
  • MediaTracker
  • MenuComponent
    • MenuBar
    • MenuItem
    • CheckboxMenuItem
    • Menu
      • PopMenu
  • MenuShorcut
  • Point
  • Polygon
  • PrintJob
  • Rectangle
  • Toolkit

Interfaces:

  • LayoutManager
  • LayoutManager2
  • MenuContainer
  • Shape

 

AWT - Componentes

Component es una clase abstracta que representa todo lo que tiene una posición, un tamaño, puede ser pintado en pantalla y puede recibir eventos.

No tiene constructores públicos, ni puede ser instanciada. Sin embargo, desde el JDK 1.1 puede ser extendida para proporcionar una nueva característica incorporada a Java, conocida como componentes Lightweight.

Los Objetos derivados de la clase Component que se incluyen en el Abstract Window Toolkit son los que aparecen a continuación:

  • Button
  • Canvas
  • Checkbox
  • Choice
  • Container
    • Panel
    • Window
    • Dialog
    • Frame
  • Label
  • List
  • Scrollbar
  • TextComponent
    • TextArea
    • TextField

Sobre estos Componentes se podrían hacer más agrupaciones y quizá la más significativa fuese la que diferencie a los Componentes según el tipo de entrada. Así habría Componentes con entrada de tipo no-textual como los botones de pulsación (Button), las listas (List), botones de marcación (Checkbox), botones de selección (Choice) y botones de comprobación (CheckboxGroup); Componentes de entrada y salida textual como los campos de texto (TextField), las áreas de texto (TextArea) y las etiquetas (Label); y, otros Componentes sin acomodo fijo en ningún lado, en donde se encontrarían Componentes como las barras de desplazamiento (Scrollbar), zonas de dibujo (Canvas) e incluso los Contenedores (Panel, Window, Dialog y Frame), que también pueden considerarse como Componentes.

Componentes de AWT.

 Etiquetas.

 El control mas sencillo de utilizar es una etiqueta es un objeto de la clase Label, y contiene un string que se muestra en pantalla. Las etiquetas son controles pasivos que no admiten ninguna interacción con el usuario. Label define los siguientes constructores:

 Label( )

Label(String str);

Label(String str,int how);

 El primer constructor crea una etiqueta vacia.  La segunda versión crea una etiqueta con la cadena especificada en la cadena, por default esta justificada a la izquierda y la tercera crea una etiqueta con el string de la forma indicada por how y estos pueden se de tres formas:

   Label.RIGTH, Label.LEFT, Label.CENTER

 Los métodos para manipular las etiquetas son:

void setText( String arg)   poner la nueva cadena a la etiqueta

String getText( )                obtener el contenido de la etiqueta

 Los alineamientos se pueden especificar mediante dos métodos:

void setAlignment(int how)

int getAlignment( )

 

Botones

El control que mas se utiliza son los botones. Un botón es un componente que contiene una etiqueta y que genera un evento cuando es pulsado, los botones son objetos de la clase Button y este proporciona dos constructores:

Button( )

Button(String Str)

El primero constructor crea un boton vacio y el segundo crea un botón con la etiqueta especificada en la cadena.

Se puede asignar la etiqueta y obtener la etiqueta utilizando los métodos:

void setLabel(String str)

String getLabel( )

Evento generado es un ActionEvent. (Interfaz ActionListener y metodo actionPerformed)


Checkbox

Los checkbox son objetos de la clase Checkbox. Un checkbox es un objeo que se utiliza para activar o desactivar una opción.   Esta formado por un pequeño cuadro que puede contener o no una marca de comprobación. Hay una etiqueta asociada a cada checkbox que describe que opción representa.  Para cambiar el estado de un checkbox sólo hay que pulsar sobre el.  Los checkbox se pueden utilizar individualmente o como parte de un grupo y los constructores son los siguientes:

Checkbox( )

Checkbox(String str)

Checkbox(String str, boolean on)

Checkbox(String str, boolean on,CheckboxGroup cbgroup)

Checkbox(String str, CheckboxGroup cbgroup, boolean on)

El primer formato crea un checkbox cuya etiqueta es vacia y el estado está no seleccionado.  El segundo formato crea un checkbox cuya etiqueta esta especificada en str e igualmente no esta seleccionada. El tercer formato crea un checkbox cuya etiqueta esta especificada en str y puede estar seleccionado si on es true y si esta en false no esta seleccionado. El cuarto y quinto formato crea un checkbox cuya etiqueta esta especificada en str y si no pertenece a ningun checkboxgroup entonces debe de estar a null y on especifica si esta seleccionado o no.

Los méodos utilizados para el manejo de los checkbox son:

boolean getState( )                      devuelve el estado del checkbox (seleccionado o no)

void setState(boolean on)            establece el estado del checkbox (seleccionado o no)

String getLabel( )                         devuelve la etiqueta asignada al checkbox

void setLabel(String str)               establece la etiqueta al checkbox

 

Evento generado  es ItemEvent. (Interfaz ItemListener y método itemStateChanged)

CheckboxGroup

Se puede crear un conjunto de checkbox que sean mutuamente excluyente en el que solo se pueda elegir a la vez uno solo y solo uno de los checkbox del grupo. A estos checkbox se les suele llamar botones de radio(radio buttons), ya que funcionan como los controles de radio para  abrir un coche donde solo abre un carro en especifico. Para crear un conjunto de grupos de checkbox mutuamente excluyentes, primero hay que definir el grupo al que pertenecen y después especificar ese grupo cuando se crean los checkbox. Los grupos de checkbox son objetos de la clase CheckboxGroup y solo se definen un constructor por defecto, que crea un grupo vacío.

Los métodos definidos para manejar los ChecboxGroup son:

Checkbox getSelectedCheckbox( ) devuelve el checkbox actualmente seleccionado

void setSelectedCheckbox(Checkbox cual) para establecer el checkbox seleccionado

Evento generado  es ItemEvent. (Interfaz ItemListener y método itemStateChanged)


Controles Choice

La clase Choice se utiliza para crear un lista pop-up de elementos para que el usuario pueda elegir uno de ellos. Por tanto, un control choice es una forma de menú. Cuando está inactivo, un componente Choice solo ocupa el espacio necesario para mostrar el elemento que esta seleccionado. Cuando el usuario hace clic en él, aparece la lista completa de opciones, y se puede realizar una nueva selección. Cada elemento de la lista es un string que aparece justificado a la izquierda en el orden en que se añadió al objeto Choice y solo esta definido un constructor que crea una lista vacia.

Para añadir un elemento a la lista, hay que llamar addItem o add que contienen los siguientes formatos:

void addItem (String name);

void add(String name);

Para determinar el elemento seleccionado se puede llamar a los siguientes métodos:

String getSelectedItem( )

int getSelectedIndex( )

int getSelectedCount( ) devuelve el número de elementos en la lista

void select(String name) para indicar el elemento que debe estar seleccionado.

void select(int index)        

String getItem(int index)  para obtener el nombre de un elemento de una posición.

 

Evento generado  es ItemEvent. (Interfaz ItemListener y método itemStateChanged)

 

Listas

La clase List proporciona una lista de selección compacta, con desplazamiento, que permite realizar selecciones multiples.  A diferencia de Choice, que solo muestra el único elemento que se puede seleccionar en el menú, se puede construir un objeto List que muestre cualquier número de opciones en una ventana. Tambien se puede configurar de manera que se puedan realizar selecciones multiples. List tiene estos constructores:

List( )

List(int numRows)

List(int numRows,boolean multipleselect)

La primera versión crea un control List que permite que haya sólo un elemento seleccionado al instante. En el segundo formato, el valor de numRows especifica el número de entradas que en la lista estaran visibles (las demas se pueden ver cuando sea necesario desplazandose por la ventana). En el tercer formato, si multipleselect es true, el usuario puede seleccionar dos o mas elementos a la vez. Si es false, solo se puede seleccionar un elemento.  Para añadir elementos a la lista, hay que llamar al método add( ), que tiene estos dos formatos:

void add(String name)                       Añade los elementos al final de la lista

void add(String name,int index)        Añade los elementos en la posición especificada

Las listas empiezan a partir de la posición cero y se puede especificar -1 para que se anexe al final de la lista.

Para determinar el elemento seleccionado se puede llamar a los siguientes métodos solo cuando se puede seleccionar un unico elemento:

String getSelectedItem( )

int getSelectedIndex( )

Para determinar el elemento seleccionado se puede llamar a los siguientes métodos solo cuando se pueden seleccionar varios elementos:

String [ ] getSelectedItems( )

int [ ] getSelectedIndexes( )

int getSelectedCount( ) devuelve el número de elementos en la lista

void select(String name) para indicar el elemento que debe estar seleccionado.

void select(int index)        

String getItem(int index)  para obtener el nombre de un elemento de una posición.

 

Evento generado es un ActionEvent. (Interfaz ActionListener y metodo actionPerformed) solo cuando se le hace clic en un elemento de la lista.

Evento generado  es ItemEvent. (Interfaz ItemListener y método itemStateChanged) cuando se selecciona o deselecciona un elemento.


Barras de desplazamiento.

Las barras de desplazamiento se utilizan para seleccionar valores continuos entre minimo y un maximo especificado. Las barras de desplazamiento pueden ser horizontales y verticales. Una barra de desplazamiento tiene varios elementos. La clase Scrollbar encapsula las barras de desplazamiento y define los siguientes constructores:

 Scrollbar( )

Scrollbar(int style)

Scrollbar(int style, int initialvalue,int tamaño, int min,int max);

El primer formato crea una barra de desplazamiento vertical, los siguientes formatos permiten especificar la orientación del la barra (Scrollbar.VERTICAL, Scrollbar.HORIZONTAL)

int initialvalue  valor inicial de la barra

int tamaño       tamaño de la barra

int min             valor minimo

int max            valor maximo

Para establecer los valores en caso de haber utilizado el primer constructor se usa:

void setValues(int initialvalue,int tamaño, int min,int max);

Para obtener y poner el valor a la barra se usa:

int getValue( )

void setValue(int valor)

para obtener los valores minimos y maximo:

int getMinimum( )

int getMaximum( )

Por defecto el incremento de la flecha es de 1 pero se puede cambiar mediante void setUnitIncrement(int nuevo incremento); por defecto el incremento de pagina es de 10 y se pueden cambiar llamando a void setBlockIncrement(int nuevo incremento).

Evento generado  es AdjustmentEvent. (Interfaz AdjustmentListener y método getAdjustmentType para determinar el tipo de ajuste.

 

TextField

La clase TextField implementa un área de entrada de texto de una sola línea que se llama control de edición. Los campos de texto permiten al usuario introducir strings y editar texto utilizando los cursores, las teclas de cortar y pegar y las selecciones que se hacen con el raton. La clase TextField es una subclase de TextComponent y TextField proporciona los siguientes constructores:

TextField( )

TextField(int numchars )

TextField(String Str)

TextField(String Str, int numchars)

int numchars especifica la anchura en caracteres

String str inicializa el campo por el texto especificado

Para obtener el texto del campo especificado se usa String getText( )

Para establecer el texto al campo se usa void setText(String texto)

Se puede seleccionar parte del texto utilizando los siguientes métodos:

String getSelectedText( )

void  select(int inicio,int final)

Se puede poner editables y verificar si es editable o no con:

void setEditable(boolean valor)

boolean isEditable( )

Si no se desea ver el caracter que se esta presionando por ejemplo pasword se usa void setEchoChar(char ch) y con boolean echoCharIsSet se puede verificar si el campo esta en el modo anterior y para ver que carácter se va a ver su usa char getEchoChar( ).

 

TextArea

Algunas veces no basta con una entrada de una sola linea para realizar ciertas tareas y para manejar esto AWT incluye un sencillo editor multilíneas llamado TextArea y los constructores son los siguientes:

TextArea( )

TextArea(int numlineas,int numcaracteres )

TextArea(String Str)

TextArea(String str,int numlineas,int numcaracteres)

TextArea(String str,int numlineas,int numcarcateres,int sBars)

Numlineas especifica la altura en lineas del área de texto y numcaracteres especifica la anchura en caracteres y el texto inicial se especifica con str y sBars especifica las barras de desplazamiento que va a tener y los valores son los siguientes:

SCROLLBARS_BOTH

SCROLLBARS_HORIZONTAL_ONLY

SCROLLBARS_NONE

SCROLLBARS_VERTICAL_ONLY

 

Textarea es una subclase de TextComponent por lo que soporta los mismo metodos que  TextField (String getText( ),

void setText(String texto), String getSelectedText( ),

void  select(int inicio,int final), void setEditable(boolean valor), boolean isEditable( )) y además agrega los siguientes métodos:

void append(String str)

void insert(String str,int index)

void replaceRange(String str,int startIndex,int endindex)

 

append añade el texto al fina del texto actual,  insert pone el texto especificado en la posicion indicada y para remplazar texto se usa replaceRange.

 

Barra de menú y menús

 Una ventana de nivel superior puede tener asociada una barra de menú, que muestre una lista de opciones de menú de nivel superior. Cada opción esta asociada a un menú desplegable. Estas opciones se implementan con MenuBar, Menu y MenuItem. En general una barra de menú tiene uno o más objetos Menú. Cada Menu tiene una lista de objetos MenuItem. MenuItem representa algo que el usuario quiere seleccionar. Debido a que Menu es una subclase de MenuItem, se puede crear una jerarquía de submenus anidados. Tambien se pueden incluir elementos de menú que se puedan verificar(o seleccionar), que son opciones de menú de la clase CheckboxMenuItem y aparece una marca al lado de ellos cuando se seleccionan.

 Para crear una barra de menú, primero hay que crear una instancia de MenuBar. Esta clase sólo define el constructor por defecto. Después, se crean instancias de Menú que definan las selecciones que se muestran en la barra. Los constructores de Menu son las siguientes:

 Menu( )

Menu(String optionName)

Menu(String optionName, boolean removable)

 La optionName especifica el nombre de la selección de menú. Si removable es true, el menú pop_up puede flotar libremente. En caso contrario permanecera siempre a la barra de menú.  El primer constructor crea un menú vacio.   Los elementos individuales del menú son de la clase MenuItem. Esta clase define los siguientes constructores:

 MenuItem( )

MenuItem(String ItemName)

MenuItem(String ItemName, MenuShortcut KeyAccel)

 ItemName es el nombre que se muestra en el menú y KeyAccel es la tecla aceleradora para ese elemento.

Se puede habilitar e deshabilitar un elemento del menú uilizando el método setEnabled( ), que tiene el siguiente formato:

    void setEnabled(boolean enabledFlag)

Si enabledFlag es true el elemento del menu esta habilitado, en caso contrario, esta deshabilitado.

Para determinar si un elemento esta habilitado o no, se utiliza el método:

boolean isEnabled( )

 Para cambiar el nombre de un elemento del menú se llama a setLabel( ) y para obtener el nombre se llama a getLabel:

void setLabel(String nuevoNombre)

String getLabel( )

 Se puede crear un elemento de menú que se pueda chequear utilizando una subclase de MenuItem llamado CheckboxMenuItem y que tiene los siguientes constructores:

CheckboxMenuItem( )

CheckboxMenuItem(String itemName)

CheckboxMenuItem(String itemName,boolean on)

 itemName es el nombre que se muestra en el menu, si on esta en true indica que la opción este marcada como  selececionada, en caso contrario no.  Se puede checar el estado de una opción utilizando boolean getState( ) y se puede activar utilizando void setState(boolean chk)

 Ya que se crearon todos los elementos primero se agrega en menubar utilizando el método setMenuBar(MenuBar mbar)

 Una vez que se ha creado cada uno de los elementos del menú hay que añadirlos a un objeto de Menú utilizando add y tiene el formato de la siguiente forma:

 MenuItem add(MenuItem item)

 Ya que se añadieron todos los elementos a un objeto de tipo menú se añaden al objeto MenuBar.    Menu add(Menu menú)

 Cada vez que se selecciona un elemento de menú se genera un evento de tipo ActionEvent   y los Checkcox generan eventos ItemEvent

El método getItem( ) de ItemEvent devuelve la referencia al elemento que ha generado ese evento.

Object getItem( )

 

FileDialog

Se puede utilizar un cuadro de dialogo para que el usuario pueda seleccionar un achivo. Para crear un cuadro de dialogo de archivo solo hay que crear un objeto de la clase FileDialog y tiene los siguientes constructores:

 FileDialog(Frame parent, String boxename);

FileDialog(Frame parent, String boxename,int how);

FileDialog(Frame parent);

 Donde parent es el propietario del cuadro de dialogo de archivo, boxename es el nombre que aparece en el titulo del cuadro de dialodo y how puede ser FileDialog.LOAD(El archivo se selecciona para lectura), FileDialog.SAVE(El archivo se selecciona para escritura).

 FileDialog tiene dos métodos que permite determinar el nombre y la ruta del archivo y son:

String getDirectory( )

String getFile( )

 Se muestra utilizando setVisible(true);

 Dialog

Se pueden crear cuadros de dialogo que permiten agrupar un conjunto de controles relacionados.  Los cuadros de dialogo se utilizan principalmente para obtener entradas del usuario. Los cuadros de dialogo pueden ser modal(toda la atención se dirige al cuadro hasta que se cierra) o no modal(se puede hacer otra cosa y después interactuar con el dialogo) y los constructores son:

 Dialog(Frame parentWindow, boolean mode)

Dialog(Frame parentWindow, String title, boolean mode)

 parentWindow es el propietario del cuadro de dialogo, title es el titulo del cuadro de dialogo, mode si es true es modal en caso contrario no modal.  dispose( ) esta definido por la clase Window y libera todos los recursos asociados a la ventana del cuadro de dialogo.

ĉ
Othoniel Rivera,
11 feb. 2015 19:31
Ċ
Othoniel Rivera,
19 feb. 2013 17:31
ĉ
Othoniel Rivera,
19 feb. 2015 7:34
ċ
Othoniel Rivera,
11 feb. 2015 19:30
ċ
Othoniel Rivera,
19 feb. 2013 17:31
Comments