Revisión de 11:41 10 abr 2012

Trabajo en proceso, espera cambios frecuentes. Tu ayuda y retroalimentación son bienvenidos. Ver página de charlas.

CURSO: JAVA

ENTORNO GRÁFICO EN JAVA

I/O Grafico |  Interfazn gráfica: swing  |  Distribuidores de contenido Layouts  |  Delegación de eventos  |  GUI Builder Jigloo  | 

INTEFAZ GRÁFICO EN JAVA

• Java define el paquete javax.swing como un conjunto de clases para desarrollar interfaces gráficas.
• Antes eran definidas en java.awt, pero estas no eran independientes de la plataforma
• siwng de JFC (Java Foundation Classes)
• En el paquete java.awt siguen estando las clases para gestionar la colocación de objetos gráficos layout y tema de eventos

Las clases de awt de denominan pesadas

Esto implica que los componenetes visuales se traducen a los correspondientes en cada plataforma

Implica que en diferentes entornos podemos tener diferentes visualizacones

El swing casi todos son ligeros

El componente no depende de su equivalente en cada plataforma, está escrito totalmente en java

• Las clases del paquete siwng están escritas en java puro y sí son independientes de la plataforma
• Siwng el paquete que define las clases para el interfaz gráfico de java.
• Actualmente aparece la tecnología javaFX que también incluye desarrollos gráficos, en desarrollos web

CLASIFICACION

• Los elementos gráficos se pueden clasificar en

1. Contenedores como una ventana contendrán otros contenedores y contenidos
2. Contenidos como un botón que necesitans un contenedor para poder aparecer

Los contenedores los tenemos de dos niveles

1. de primer nivel
2. de niveles inferiores

Componentes contenidos

• Defivan de la clase JComponent

• Estan definidos en el paquete javax.swing
• Observar que todoas empiezan por la letra J
• En los siguientes apartados estudiaremos alguno de ellos
• Con ello aprenderemos a usar cualquiera.

Componetes contenedores

Existen dos tipos de contenedores nivel superior

JWindow

Ventana sin la barra superior de título ni los botones de cerrar

import javax.swing.JWindow;
public class Ventana {
public static void main(String []s){
	JWindow w = new JWindow();
	w.setBounds(400,300,100,100);
	w.setVisible(true);
  }
}

JFrame

Es una ventana que ya se puede usar para una aplicacion con sus botones y borde por defecto

import javax.swing.JFrame;
public class marco{
public static void main(String []s){
	JFrame w = new JFrame();
        w.setTitle("Ventan de frame");
	w.setBounds(400,300,100,100);
	w.setVisible(true);
  }
}

JDialog

Ventana de propósito específico como pedir un dato...

import javax.swing.JDialog;
public class Dialogo{
public static void main(String []s){
	JDialog w = new JDialog();
        w.setTitle("Ventan de dilogo");
	w.setBounds(400,300,100,100);
	w.setVisible(true);
  }
}

JApplet

Ventana para ver en un navegador

• Son componentes pesados (Dentro de los componenetes swing son los únicos que tienen esta excepción)

Se caracterizan por

Sólo son contenedores y no pueden ser contenidos en otro contenedor

Son necesarios para que haya un interfaz gráfico

de nivel inferior

Componentes de nivel superior

A su vez tienen tres paneles El panel es una región de contenido del objeto

• Panel de cristal ===>Contiene el resto de paneles, se usa para albergar todos los eventos que puedan ocurrir en cualquiera de los paneles contenidos
• Panel de contenidos ==> Es el panel que va a contener el resto de los objetos (contenedores y contenidos)
• Panel de capas ==> Permite establecer un valor de profundidad de capas.

Fuente de la image http://docs.oracle.com/javase/tutorial/figures/ui/ui-rootPane.gif

• En realidad es bastante trasparente para el desarrollador esta existencia de capas,
• El desarrollador por lo general interactuaemos con el panel de contenidos.

Creando un interfaz gráfico

• Usaremos el contenedor de primer nivel JFrame

• Al crear un interfaz gráfico debemos trabajar con la clase JFrame

La clase JFrame tiene muchos métodos

Métodos importantes

setTitle(String titulo) Poner el título de la ventana, también posible en constructor.
setBounds(int posx, int posy, int alto, int ancho) ubicación (esquina superior izquierda y tamaño)
setVisible (Por defecto una ventna no es visible (Objeto pesado)
setDefaultCloseOperation (que hacemos con la aplicación al cerrar la ventana)
setPack() para que se recargue la pantalla (si hacemos cambios)

• Iremos viendo muchos más métodos según los necesitemos
• Suelen ser muy .

Cómo crear una aplicación con ventanas

1. Creamos un objeto de la clase JFrame
2. Hacemos una clase que extienda de JFrame

import javax.swing.JFrame
class  MiVentana{
 //Atrubuto
 JFrame ventana; 
 //Constructor
 MiVentana{
    ventana = new JFrame("Primera Ventana");
    ventana.setBounds(100,100,300,400);
    ventana.setVisible(true);
 }
 public static void main(String s[]){
 MiVentana v = new MiVentana();
 }

import javax.swing.JFrame
class  MiVentana extends JFrame{
 //Constructor
 MiVentana{
     setTitle("Primera Ventana");
     setBounds(100,100,300,400);
     setVisible(true);
 }
 public static void main(String s[]){
 MiVentana v = new MiVentana();
 }

• Hacemos que mi clase sea un JFrame

Cajas de texto

• Elementos donde escribir texto
• Simpre retornan su contenido como un string

Tenemos 5 tipos diferentes de cajas de texto como a continuación veremos

JTextField
JTextArea
JPasswordField
JFormattedField
JTextPane

JTextField

Construtores

JTextField() 
JTextField(int columnas) 
JTextField(String texto) 
JTextField(String text, int columnas) 
JTextField(Document doc, String texto, int columnas) 

• El número de columnas detalla la achura en caracteres,
• El texto sería el que aparece como contenido de la caja de texto

Docuemnt es una interfaz de javax.swing.text.Document que permite especificar el documento que va a contener la caja de texto

• Permite manipular el texto antes de que aparezca en la caja de texto

JTextField y Document

• Document es una interfaz definida en el paquete javax.swing.text
• Esta interfaz está implementada por la clase PlaintDocument
• Permite controlar el texto que se va a introducir Muy util cuando lo queremos adaptar a XML o a HTML

Aplicaciones directas y sencillas

1. Texto siempre en mayúsculas
2. solo números
3. Limitar el número de caracteres
4. etc

Su uso es no es del todo directo pero abre las puertas a un gran abanico de posibilidades Veamos un ejemplo

import java.awt.FlowLayout;
import javax.swing.JFrame;
import javax.swing.JTextField;
//Clases que necesito para Document
import javax.swing.text.AttributeSet; //atributos de insertString
import javax.swing.text.BadLocationException; //Excepcion que puede lanzar el mñetodo insertString
import javax.swing.text.PlainDocument; //Clase que implementa la interfaz Document
 
 
public class FormatoTexto extends PlainDocument {
	 private static final long serialVersionUID = 1L;
	   private int limit;
	   FormatoTexto(int limit) {
		   System.out.print("Hola en constructor");
		   this.limit = limit;
	  }
	   //Este método se ejecuta después de haber insertado los caracteres, pero antes de que aparezcan en la caja de texto
  public void insertString(int offset, String str, AttributeSet attr)
	      throws BadLocationException {
	    if (str == null)
	      return;
	    if ((getLength() + str.length()) <= limit) {
	    	System.out.println("offset "+offset + "str "+str);
	    	super.insertString(0, str.toUpperCase(), attr);
	    }
	  }
 
	public static void main(String []s){
		System.out.println("Hola1");
		JFrame v = new JFrame("Probando texto con control");
		v.setBounds(100,100,200,200);
		JTextField T= new JTextField(15);
		//Asociamos el Document a la caja de texto y le pasamos el 10 que es el número de caracteres máximo
		T.setDocument(new FormatoTexto(10));
 
		v.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	    v.setLayout(new FlowLayout());
	    v.add(T);
	    v.setVisible(true);
		System.out.println("hola5");
	}
}

Probar a hacer que los caracteres aparezcan en mayúscula

JPasswordField

• Es un TextField, para inserter contraseñas.
• El contenido no se puede ver en claro

Los constructores son los mismo que la clase de la que deriva. Añade (entre otros), los siguientes métodos propios

char getEchoChar()   Nos da el caracter que se visualiza al escribir
char[] getPassword() Nos da el contenido de la caja de texto como un vector de caracteres
void setEchoChar(char c) Especificamos el carácter que se visualizará al escribir la password

Los constructores son

JFormattedTextField ();
JFormattedTextField(Format formato)
JFormattedTextField(JFormattedTextField.AbstractFormatter  formato)
JFormattedTextField(JFormattedTextField.AbstractFormatterFactory factory) 
JFormattedTextField(JFormattedTextField.AbstractFormatterFactory factory, Object currentValue) 
JFormattedTextField(Object valor);

• Ofrece total flexibilidad y puede suplir muchas de las acciones que hemos visto con el objeto Document en el constructor de

JTextField A continuación vamos a ver formas de crear formatos

De manera directa

JFormattedTextField(Object valor);
Con este constructor podemos especificar un tipo concreto (Integer, String,...)

Permite insertar cualquier valor, pero al perder el foco dejaría el último valor válido.

JFormattedTextField(Integer()); 
JFormattedTextField(String()); 
En este caso cuando la caja de texto pierde el foco, comprueba el texto escrito por el usuario. Si es correcto, lo guarda de forma que el   método getValue() nos devolverá el nuevo valor. Si es incorrecto, pondrá automáticamente el último valor bueno, deshaciendo el cambio hecho por el usuario. 

El comportamiento depende de un valor constante que se puede cambiar, según la tabla siguiente

COMMIT  El texto se sigue quedando en pantalla 
REVERT   El texto se quita y se queda la última entrada correcta
COMIT_OR_REVERT 
PERSIST