Bienvenidos a todos a un nuevo post, este
será el último dedicado a las disposiciones. Cualquier duda ya sabéis que lo
podéis comentar a través de los comentarios del blog o enviarme un correo a amizba@gmail.com
Aunque parece que son más fáciles que las
disposiciones que ya hemos visto tipo Layout, las disposiciones
libres tienen sus inconvenientes, además de que hay que trabajar constantemente
con coordenadas, puede ocurrir que nuestra aplicación utilizando una
disposición libre en otro equipo no se vea igual, depende de la resolución,
entre otras características, por lo que es un inconveniente bastante grave.
La solución a esto es crearnos nuestra propia
disposición, es decir, crear nuestra propia clase que sea capaz de colocar los
componentes tal y como deseamos.
Para crear esta clase es necesario que
implemente la interfaz LayoutManager que contiene una serie de
métodos obligatorio:
· addLayoutComponent(String
nombre, Component componente)
· minimumLayoutSize(Container
padre)
· LayoutContainer(Container
padre)
· preferredLayoutSize(Container
padre)
· removeLayoutComponent(Component
componente)
Sería conveniente ir a la API de Java para conocer un poco
más esta interfaz y sus métodos. Estos métodos reciben como parámetro un objeto
de tipo Container por lo que convendría echar un vistazo de
nuevo a la API de Java para conocer también
la clase Container que implementa los métodos getComponentCount() y getComponent(int
i).
La gran ventaja de esto, es que al crear la
clase para que nos ubique los elementos en la ventana donde queramos es que la
podemos reutilizar en otras aplicaciones.
Para ver todo esto lo vamos a hacer mediante un ejemplo, como siempre, va a consistir en ubicar los elementos a la izquierda, por parejas, es decir, una etiqueta, al lado un campo de texto, justo debajo otra etiqueta y al lado un campo de texto, algo similar a esto:
Nuestro código inicial para empezar la
práctica es el siguiente:
package graficas;
import javax.swing.*;
public class
DisposicionPropia {
public static void main(String[] args) {
MarcoPropio mimarco = new MarcoPropio();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoPropio
extends JFrame {
public MarcoPropio(){
setTitle("Creación de una
disposición");
setBounds(450, 350, 600, 400);
setVisible(true);
LaminaPropia milamina = new LaminaPropia();
add(milamina);
}
}
class LaminaPropia
extends JPanel{
public LaminaPropia() {
}
}
Es un código que ya hemos visto
anteriormente, está formado por la clase principal main , la
clase MarcoPropio y la clase LaminaPropia. Nos
situamos dentro del constructor de la lámina, lo primero que vamos a indicarle
que no vamos a utilizar ninguna disposición para que tampoco Java utilice
el Layout por defecto, esto lo hacemos con el método setLayout y
le pasamos como parámetro null.
public LaminaPropia() {
setLayout(null);
}
Nos creamos los objetos, las etiquetas y los
campos de texto, los añadimos a la lámina:
public LaminaPropia() {
setLayout(null);
JLabel nombre = new JLabel ("Nombre:
");
JLabel apellido = new JLabel ("Apellido:
");
JTextField c_nom = new JTextField();
JTextField c_ape = new JTextField();
add(nombre);
add(apellido);
add(c_nom);
add(c_ape);
}
Una vez hecho esto tenemos que indicarle que
nos lo ubique en alguna parte de la ventana, concretamente en la parte
izquierda, por lo que nos vamos a crear una clase que nos ubique los elementos
en la ventana.
class EnColumnas implements LayoutManager{
}
Nos da un error ya que esta interfaz nos
obliga a declarar los métodos que posee, eso no significa que vayamos a
utilizar todos, pero si declararlos, Eclipse tiene la opción de mostrarlos de
forma automática:
class EnColumnas implements LayoutManager{
@Override
public void
addLayoutComponent(String name, Component comp) {
// TODO
Auto-generated method stub
}
@Override
public void
removeLayoutComponent(Component comp) {
// TODO
Auto-generated method stub
}
@Override
public Dimension
preferredLayoutSize(Container parent) {
// TODO
Auto-generated method stub
return null;
}
@Override
public Dimension
minimumLayoutSize(Container parent) {
// TODO
Auto-generated method stub
return null;
}
@Override
public void
layoutContainer(Container parent) {
// TODO
Auto-generated method stub
}
}
Solo vamos a utilizar uno de los métodos, es
el que he sombreado en amarillo. Antes de programar nada en este método y como
vamos a trabajar con coordenadas nos creamos dos variables, x, y las
inicializamos:
private int x=20;
private
int y=20;
Las variables las creamos antes de la última
llave de cierre de apertura. Dentro del método nos creamos dos variables: contador y n.
public void
layoutContainer(Container parent) {
int contador=0;
int n=parent.getComponentCount();
}
La variable contenedor, para
saber cuántos elementos llevamos agregados en un momento concreto.
La variable n, para saber cuántos
elementos hemos agregados al contenedor, que va a ser igual al método getComponentCount() que
nos contabiliza cuantos elementos hemos agregado.
A continuación, utilizamos un for para
recorrer de forma individual todos los elementos, por ejemplo, si tenemos 6
elementos ubicados en la ventana, este 6 se almacena en la variable n,
mediante este bucle vamos a recorrer todos los elementos de forma individual
para ubicarlos en la ventana.
public void
layoutContainer(Container parent) {
int contador=0;
int n=parent.getComponentCount();
for(int i=0; i<n; i++) {
contador++;
}
}
Luego tenemos que ubicar el elemento que
estamos evaluando en un momento concreto y para ello utilizamos el método getComponent() que
nos pedía por parámetro un valor de tipo entero, en este caso, va a ser la
variable i. Este método que pertenece a la clase Container devuelve
un objeto de tipo componente, por lo que necesitamos crear una variable de
tipo component a la que vamos a denominar c donde
almacene el objeto del componente que devuelva este método.
for(int i=0; i<n; i++) {
contador++;
Component c=parent.getComponent(i);
}
Esta línea lo que hace es lo siguiente: con
el bucle for la primera vez que entramos estamos evaluando el
primer componente que hemos agregado que se supone que está en la posición 0,
una vez que hemos hecho esto la variable contador se
incrementa en 1 y se almacena en la variable c un objeto de
tipo component el primer componente o elemento, esto nos
permite ubicar la variable c, es decir, el elemento donde deba con
lo cual la siguiente línea de código será:
for(int i=0; i<n; i++) {
contador++;
Component c=parent.getComponent(i);
c.setBounds(x, y, 100, 20);
}
Una vez que nos ha colocado el primer
elemento, lo que hacemos después es incrementar la variable x para que el
siguiente elemento me lo ponga a la derecha.
for(int i=0; i<n; i++) {
contador++;
Component c=parent.getComponent(i);
c.setBounds(x, y, 100, 20);
x+=100;
}
También necesitamos incrementar la
variable y, tenemos que incrementarla cuando hemos agregado nuestra
primera pareja de componentes, es aquí cuando entra en juego la variable contador,
esta variable nos permite saber si hemos agregado un elemento, dos elementos,
tres elementos… Por lo que podemos indicarle que cuando la variable contador
sea par incremente la variable:
for(int i=0; i<n; i++) {
contador++;
Component c=parent.getComponent(i);
c.setBounds(x, y, 100, 20);
x+=100;
if(contador%2==0) {
y=20;
y+=40;
}
}
Con esto ya tendríamos terminada la clase,
volvemos al constructor de la lámina, en el método setLayout() que
en un principio le hemos indicado como parámetro null para que no nos utilice
el Layout por defecto, tenemos que indicarle en lugar del parámetro null que
ha de utilizar el Layout de esta clase:
setLayout(new EnColumnas());
Si probáis os va a salir la etiqueta
“Nombre”, a continuación la etiqueta “Apellidos” y debajo los campos de texto.
Esto es debido a como los hemos añadido los elementos en la lámina, hemos de
colocarnos de la siguiente forma:
add(nombre);
add(c_nom);
add(apellido);
add(c_ape);
Y esto así todo, os espero en el
próximo post. Saludos!
8.3.3 Disposición libre <<
>> 8.4 VENTANAS EMERGENTES
No hay comentarios:
Publicar un comentario