La clase TextBox permite introducir y editar texto a pantalla completa. Es como un pequeño editor de textos.

Veamos el constructor:

TextBox (String título, String texto, int tamaño_max, int limitación)
Las limitaciones pueden ser alguna de los siguientes:

ANY - Sin limitación
EMAILADDR - Sólo una dirección de email
NUMERIC - Sólo se permiten números
PASSWORD - Los caracteres no serán visibles
PHONENUMBER - Sólo números de telefono
URL - Sólo direcciones URL

El parámetro tamaño_max indica el máximo número de caracteres que se pueden introducir. El parámetro texto es el texto inicial que mostrará la caja.

TextBox texto = new TextBox ("Mensaje", "", 256, TextField.ANY);
Para conocer el texto que contiene la caja puede usarse los métodos siguientes:

String getString()

int getChars (char[] texto)
En el caso de getChars(), el texto será almacenado en la variable texto en forma de array de caracteres.

La clase Form.- Un Form es un elemento de tipo contenedor, es decir, es capaz de contener una serie de elementos visuales con los que podemos construir interfaces más elaboradas. Los elementos que podemos añadir a un formulario son:

StringItem
ImageItem
TextField
DateField
ChoiceGroup
Gauge

Como vemos en el diagrama, la clase Form es capaz de manejar objetos derivados de la clase Item. La clase Item representa a un elemento visual que no ocupará toda la pantalla, sino que formará parte de la interfaz de usuario junto con otros elementos.

Ya hemos visto un ejemplo de la clase Form en el programa de ejemplo del anterior capítulo. En el ejemplo, creamos un elemento de tipo StringItem y lo añadimos al formulario con el método append().

Los métodos de la clase Form que nos permiten añadir, eliminar y modificar elementos del formulario son las siguientes:

int append(Item elemento)
Como ya sabes, append() añade al formulario un elemento. Cada vez que añadimos algo al formulario, a éste se le asocia un número de índice para poder hacer referencia a él posteriormente. El primer elemento que añadamos tendrá el valor cero, y así sucesivamente. Si todo va bien, el método retornará el índice del elemento.

void delete(int índice)
El método delete() elimina un elemento del formulario.

void insert(int índice, Item elemento)
El método insert() inserta un elemento en la posición que indiquemos en el primer parámetro.

Si lo que queremos es sustituir un elemento por otro utilizaremos el método set():

void set(int índice, Item elemento)
En algún momento es posible que necesitemos conocer el número de elementos del formulario. El método size() nos muestra esta información:

int size()
Por último, necesitaremos algún mecanismo que nos permitan responder a cambios en los elementos como, por ejemplo, un cambio de valor. El mecanismo es similar al de los comandos que vimos algunas líneas atrás. Hemos de implementar la interface ItemStateListener. Concretamente el método siguiente:

void itemStateChanged(Item elemento)
Para indicar al formulario cuál será la clase que responderá a los eventos podemos utilizar:

formulario.setItemStateListener(this);
Si la clase que manejará los eventos es distinta a la que contiene el formulario sustituiremos el operando this por la clase deseada.

La clase StringItem.- Esta clase ya la conocemos del ejemplo del capítulo anterior. Su función es añadir etiquetas de texto al formulario.

El constructor de la clase StringItem es el siguiente:

StringItem (String etiqueta, String texto)
Si sólo queremos mostrar un texto, sin etiqueta, paramos una cadena vacía como primer parámetro ("").

Como vimos antes, sólo hay que utilizar el método append() de la clase Form para añadir el texto.

La clase StringItem nos provee además de dos métodos:

String getText()

void setText(String texto)

El primer método devuelve el texto de un StringItem, el segundo, establece el texto que le pasamos como parámetro.

La clase ImageItem.-  Con esta clase podemos añadir elementos gráficos a un formulario. El constructor tiene la siguiente forma:

ImageItem (String etiqueta, Image img, int layout, String texto_alternativo)
El parámetro texto_alternativo es un texto que se mostrará en el caso en el que no sea posible mostrar el gráfico. El parámetro layout indica cómo se posicionará el gráfico en la pantalla. Sus posibles valores son:

LAYOUT_DEFAULT
LAYOUT_LEFT
LAYOUT_RIGHT
LAYOUT_CENTER
LAYOUT_NEWLINE_BEFORE
LAYOUT_NEWLINE_AFTER

Las cuatro primeras son auto explicativas. LAYOUT_NEWLINE_BEFORE añade un salto de línea antes de colocar la imagen. LAYOUT_NEWLINE_AFTER hace precisamente lo contrario, primero añade la imagen y después un salto de línea.

Para cargar una imagen, utilizamos el método createImage() de la clase Image. Veamos un ejemplo:

Image img;
try {
 img = Image.createImage("/logo.png");
} catch (IOException e) {
  System.err.println("Error: " + e);
}
Añadir la imagen al formulario es similar a cómo lo hacemos con un StringItem:

ImageItem img = new ImageItem ("", "/logo.png" ,ImageItem.LAYOUT_DEFAULT, "logotipo");

formulario.append(img);
Hay que tener en cuenta que las imágenes han de almacenarse en el directorio 'res' que crea KToolBar, por lo tanto la barra (/) hace referencia a la raíz de este directorio.

La clase TextField.- La clase TextField es muy similar a la clase TextBox que ya vimos anteriormente. La principal diferencia es que TextField está diseñada para integrarse dentro de un formulario en vez de ocupar toda la pantalla.

El constructor de esta clase es similar al de TextBox:

TextField (String etiqueta, String texto, int tamaño_max, int limitación)
Los parámetros tienen el mismo significado que TextBox, exepto el primero, que permite especificar una etiqueta.

La clase DateField.- Con DateField tenemos una herramienta muy intuitiva que permite la entrada de datos de tipo fecha o tipo hora.

DateField (String etiqueta, int modo)
El parámetro modo puede tomar cualquiera de los siguientes valores:

DATE
TIME
DATE_TIME
Para seleccionar la entrada de una fecha o una hora.

DateField fecha=new DateField("fecha",DateField.DATE);
formulario.append (fecha);
La clase DateField nos provee estos dos métodos:

Date getDate()
void setDate (Date fecha)
El primer método recupera el valor del elemento DateField, y el segundo lo establece.

La clase ChoiceGroup.- Este elemento es similar a la clase List, pero al igual que DateField, puede incluirse en un formulario, de hecho, su constructor es básicamente el mismo que el de List:

ChoiceGroup (String etiqueta, int tipo_lista, String[] elementos, image[] imágenes)
Excepto el primer parámetro (que ya conocemos), el resto es exactamente el mismo que el de la clase List.

String[] estados = {"Casado","Soltero","Divorciado","Viudo"};

ChoiceGroup estado = new ChoiceGroup ("Estado", List.EXCLUSIVE, estados, null);

screen.append(estado);

La clase Gauge.- La clase Gauge representa un elemento tipo barra de estados que permite indicar un valor gráficamente.

El constructor tiene la siguiente forma:

Gauge (String etiqueta, bolean interactivo, int val_max, int val_ini)
Los parámetros val_ini y val_max indican el valor inicial y el valor máximo de la barra gráfica. El parámetro interactivo si está a true, permitirá al usuario modificar el valor de la barra, si no, sólo podrá mostrar información.

La clase Gauge nos ofrece cuatro métodos muy útiles:

int getValue()
void setValue(int valor)
int getMaxValue()
void setMaxValue(int valor)

Las dos primeros para establecer y recoger el valor del Gauge, y las otras tienen el cometido de establecer y recoger el valor máximo del Gauge.

Gauge estado = new Gauge ("estado", false, 1, 100);
fomulario.append(estado);

El siguiente programa muestra el uso de varios elementos en un formulario a la vez.

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class UI extends MIDlet implements CommandListener {
 private Command exitCommand;
 private Display display;
 private Form screen;
 
 public UI() {
  String[] estados = {"Casado","Soltero","Divorciado","Viudo"};
  
  // Obtenemos el objeto Display del midlet.
  display = Display.getDisplay(this);
  
  //  Creamos el comando Salir.
  exitCommand = new Command("Salir", Command.EXIT,2);
  
  // Creamos la pantalla principal (un formulario)
  screen = new Form("Interfaz de usuario");
  
  // Creamos y añadimos los elemento que vamos a utilizar
  TextField nombre = new TextField("Nombre","",30,TextField.ANY);
  DateField fecha_nac = new DateField("Fecha de nacimiento", DateField.DATE);
  ChoiceGroup estado = new ChoiceGroup("Estado",List.EXCLUSIVE,estados,null);
  screen.append(nombre);
  screen.append(fecha_nac);
  screen.append(estado);
  
  
  // Añadimos el comando Salir e indicamos que clase lo manejará
  screen.addCommand(exitCommand);
  screen.setCommandListener(this); 
 } 

 public void startApp() throws MIDletStateChangeException {
  // Seleccionamos la pantalla a mostrar
  display.setCurrent(screen); 
 }
 
 public void pauseApp() {
 }
 
 public void destroyApp(boolean incondicional) {
 }
 
 public void commandAction(Command c, Displayable s) {
  // Salir
  if (c == exitCommand) {
   destroyApp(false);
   notifyDestroyed(); 
  } 
 }
}