Tutoriales
Enlaces
Licencia
Esta obra está bajo una licencia de Creative Commons.
Para reconocer la autoría debes poner el enlace https://old.chuidiang.org
En este tutorial vamos a hacer un pequeño editor de textos. Lo usaremos para aprender sobre la marcha las siguientes cosas:
Iremos explicando todo esto sobre la marcha. Si quieres ir al grano, en editor-1.0-sources.jar tienes los fuentes completos y en editor-1.0.jar el programa compilado. Ejecútalo con
java -jar editor-1.0.jar
Lo primero de todo es pensar qué pinta queremos que tenga nuestra ventana del editor. Como es sencillota, nos bastará con un área de texto grande que ocupe casi toda la ventana y es el área donde podremos escribir nuestras cartas, trabajos y documentos. Arriba, en horizontal, una barra de menú con dos opciones: Archivo y Editar, similar a la de muchos editores que hay por ahí.
Archivo será un menú con las opciones de Salvar fichero, Cargar fichero y Salir.
Editar tendrá algunas de las cosas típicas de editar: Buscar, Cortar, Copiar y Pegar.
Vaya, la pinta del editor puede ser como la de la figura.
La ventana principal será un JFrame, que es el componente adecuado para ventanas principales.
Un Layout es una clase que hay dentro de las ventanas y de los paneles donde se colocan otros comonentes, como botones, listas, menús, etc. Esta clase Layout es la que decide cómo se van a colocar esos componentes, si en forma de matriz, en fila, en columna, etc. Java tiene muchos Layouts disponibles, como BorderLayout, FlowLayout, GridLayout, etc. Cada uno de ellos coloca los botones que recibe de una forma especial dentro de la ventana. Para la colocación que queremos, un area grande con una barra estrecha arriba, el BorderLayout es estupendo y ¡Oh casualidad de las casualidades! es justo el Layout que tiene el JFrame dentro por defecto.
Al BorderLayout sólo hay que decirle en qué posición queremos el componente, NORTH, SOUTH, CENTER, WEST o EAST. El código para hacer esta ventana es similar a este
// JFrame con su título
arriba
JFrame v = new JFrame ("Editor tonto de textos");
JMenuBar barraMenu = new JMenuBar();
JTextArea areaTexto = new JTextArea();
v.getContentPane().add(barraMenu, BorderLayout.NORTH);
v.getContentPane().add(areaTexto, BorderLayout.CENTER);
A la ventana JFrame no se le añaden directamente los componentes. Hay que llamar a su método getContentPane() para que nos dé el panel interno que tiene la ventana. Dentro de ese panel es donde realmente van los componentes. En el código hemos creado el JFrame. Luego hemos creado la barra de menú JMenuBar, el area de texto un JTextArea y los hemos metido dentro del contenedor del JFrame. Uno al NORTE y otro en el CENTRO. El BorderLayout hace que el componente del CENTRO ocupe casi toda la ventana. El componente del NORTE lo ajusta a la parte de arriba, ocupando todo de izquierda a derecha. Justo lo que tenemos en la figura anterior.
El JTextArea es un componente simple para escribir varias líneas de texto. Tenemos varios posibles editores de texto, pero o no nos valen o son demasiado complejos para lo que queremos:
Bueno, una vez decidido que useramos el JTextField, debemos saber varias cosas de él para configurarlo adecuadamente.
La primera es que su tamaño es el justo para el texto que lleva dentro. Es decir, inicialmente, su tamaño es de una fila de letras de alto y cero pixels de ancho, ya que no tiene texto. Según vamos escribiendo, va cambiando de tamaño. Esto no es buena idea dejarlo así, ya que nos pueden pasar cosas raras. En el constructor del JTextArea podemos decirle cuántas filas queremos que tenga y cuántas columnas. En el ejemplo vamos a poner 25 filas y 80 columnas, rememorando a los antiguos terminales verdes de los ordenadores, de mucho antes que las pantallas planas multicolorín que tenemos ahora.
JTextArea areaTexto = new JTextArea(25,80);
La segunda es que un JTextArea no tiene barras de scroll, así que si escribimos más de la cuenta, simplemente dejaremos de ver lo que escribmos. Para poner barras de scroll tenemos en Java el JScrollPane. Es un panel que admite dentro un componente. Si el componente es más grande que lo que se puede ver, le pone las barras de scroll según hagan falta. Para meter un componente como nuestro JTextArea dentro de un JScrollPane, se lo pasamos como parámetro al construir el JScrollPane o bien luego llamamos a setViewportView() del JScrollPane.
JScrollPane scroll = new JScrollPane(areaTexto);
// o bien
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(areaTexto);
En ningún caso debemos usar el método scroll.add(areaTexto) puesto que no funcionará bien.
La tercera cosa que debemos saber es que el JTextArea por defecto no parte automáticamente las líneas. O vamos apretando la tecla de retorno de carro cada vez que queramos partir una línea, o escribiremos el Quijote en usa sola línea de 2 km. Tenemos dos métodos para que se partan las líneas automáticamente. En uno decimos que sí, que queremos que las líneas se partan automáticamente. Con el otro decimos que queremos que se respeten las palabras, que no hay que partir palabras a la mitad. Las líneas hay que partirlas aprovechando los espacios entre palabras.
// Para que se partan automáticamente
las líneas al llegar al final
areaTexto.setLineWrap(true);
// Para que el partido se haga respetando
las palabras. Sólo se parte la
// línea en los espacios entre palabras.
areaTexto.setWrapStyleWord(true);
Con todo esto, la forma de crear el JTextArea y añadirlo al JFrame será así
JTextArea areaTexto = new JTextArea(25,80);
areaTexto.setLineWrap(true);
areaTexto.setWrapStyleWord(true);
JScrollPane scroll = new JScrollPane(areaTexto);
v.getContentPane().add(scroll, BorderLayout.CENTER);
Siguiente paso... construir el JMenuBar.