Hola a todos, continuamos con las
disposiciones, en este post vamos a ver la disposición en muelle.
Para utilizar una disposición en muelle vamos
a necesitar por un lado la clase SpringLayout y por otro lado
la clase Spring. La clase SpringLayout lo que hace
es decirle a nuestro contenedor, por ejemplo, a nuestra lámina que tipo de
disposición vamos a trabajar, esta clase tiene un método putConstraint(String
e1, Component c1, int pad, String e2, Component c2), que tiene cinco
parámetros cuando estemos realizando la práctica veremos su uso. Y la
clase Spring lo que hace es construirnos el muelle, un muelle
virtual, para construir este muelle la clase tiene un método static
constant(int a, int b, int c) tiene tres parámetros aunque puede tener
uno solo, estos argumentos hacen referencia a la capacidad de elasticidad del
muelle.
La disposición en muelle da el efecto que al
redimensionar la ventana alargándola o achatándola los elementos que contiene
la ventana se estiran y se encogen como si estuvieran unidos por un muelle
virtual.
Para ver esto lo vamos a hacer como siempre con una práctica que va a consistir en crear un marco o ventana, crear tres botones en la parte superior y colocar el muelle virtual entre estos elementos de la siguiente forma:
La primera colocación del muelle desde la
esquina izquierda del borde de la lámina al borde de la esquina del primer
botón. La segunda colocación del muelle desde la esquina derecha del primer
botón a la esquina izquierda del segundo botón. La tercera colocación del
muelle desde la esquina derecha del segundo botón a la esquina izquierda del
tercer botón. La cuarta colocación del muelle desde la esquina derecha del
tercer botón a la esquina derecha del borde de la lámina. Fijaros que solo hay
un muelle, aunque haya cuatro muelles en la imagen, es un solo muelle que va
unido a estos componentes. NO HAY CUATRO MUELLES.
Para empezar y ver cómo hacer todo esto como
siempre con una práctica cuyo código inicial es el siguiente:
package graficas;
import javax.swing.*;
public class
DisposicionMuelle {
public static void main(String[] args) {
MarcoMuelle
mimarco = new MarcoMuelle();
mimarco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
class MarcoMuelle
extends JFrame {
public MarcoMuelle(){
setTitle("Disposición en
muelle");
setBounds(300, 400, 900, 250);
setVisible(true);
LaminaMuelle milamina = new LaminaMuelle();
add(milamina);
}
}
class LaminaMuelle
extends JPanel{
public LaminaMuelle() {
}
}
Si ejecutamos este código tenemos una ventana alargada como la siguiente:
Lo primero es crearnos los tres botones y
añadirlos a la lámina, por lo que nos colocamos en el constructor de la lámina:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
add(boton1);
add(boton2);
add(boton3);
}
Si ya no le indicamos nada más y ejecutamos el archivo, vemos que por defecto la disposición de los botones es FlowLayout, que es la disposición por defecto que tiene Java:
Si probáis a redimensionar la ventana los
botones siempre aparecen centrados y a la misma distancia.
Si cambiamos la disposición por defecto por
una disposición en muelle conseguimos que al redimensionar la ventana también
cambiaría la distancia que hay entre los botones ya que estos botones no
estarían fijos sino unidos por un muelle virtual.
Para establecer la disposición en muelle,
antes de añadir los botones al marco añadimos la disposición:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
}
Si probamos ahora:
Solo aparece un botón, pero no es que haya
solo un botón, sino, que los otros dos están debajo de este ya que hemos
utilizado este tipo de disposición y no hemos creado el muelle y tampoco le
hemos dicho donde tiene que ir colocado.
El siguiente paso es construir el muelle
después de añadir los botones a la lámina:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0, 10, 100);
}
Si vamos a la API de Java para ver el uso de
este método vemos que nos pide tres parámetros, el primero es el valor mínimo,
el segundo valor es un valor por defecto yo le he puesto 10 y el valor
máximo le he puesto un 100. En la API veréis que hace un cálculo complejo para
calcular la elasticidad del muelle, el valor mínimo, máximo…
Una vez construido el muelle tenemos que colocarlo, y aquí viene lo engorroso. La primera colocación del muelle va estar entre el borde izquierdo de la lámina y el borde izquierdo del primer botón:
Para ello utilizamos el método PutConstraint():
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0,
10, 100);
milayout.putConstraint(SpringLayout.WEST,
boton1, mimuelle, SpringLayout.WEST, this);
}
El primer parámetro hace referencia a donde
comienza el muelle que es en el borde izquierdo del primer botón y tiene que
acabar en el borde izquierdo de la lámina, la posición del borde izquierdo del
botón está en una disposición ubicada en la parte oeste. El segundo parámetro
hace referencia al elemento botón 1. El tercer parámetro es el muelle que vamos
a colocar. El cuarto parámetro es el borde izquierdo de la lámina que está en
una disposición ubicada en la parte oeste. Y el quinto parámetro hace
referencia al contenedor, como es la lámina que estamos utilizando como
contenedor y estamos en el constructor de la lámina utilizamos la palabra this.
Vamos a realizar la segunda colocación del muelle:
Esta segunda posición del muelle va desde la
esquina izquierda del botón 2 al borde derecho del botón 1:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0,
10, 100);
milayout.putConstraint(SpringLayout.WEST, boton1, mimuelle, SpringLayout.WEST, this);
milayout.putConstraint(SpringLayout.WEST,
boton2, mimuelle, SpringLayout.EAST, boton1);
}
El primer parámetro hace referencia al borde
izquierdo del segundo botón. El segundo parámetro hace referencia al componente
que estamos utilizando que es el botón 2. El tercer parámetro colocamos el
muelle. El cuarto parámetro es el destino que es la parte este del segundo
botón. Y el último parámetro es el segundo componente que es el primer botón.
Vamos ahora a la posición del tercer muelle:
Va desde el borde izquierdo del tercer botón
al borde derecho del segundo botón:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0,
10, 100);
milayout.putConstraint(SpringLayout.WEST, boton1, mimuelle, SpringLayout.WEST, this);
milayout.putConstraint(SpringLayout.WEST, boton2, mimuelle, SpringLayout.EAST, boton1);
milayout.putConstraint(SpringLayout.WEST,
boton3, mimuelle, SpringLayout.EAST, boton2);
}
El primer parámetro es el borde izquierdo del
tercer botón, que esta una disposición West, el segundo parámetro
es el botón que estamos trabajando que es el botón 3, el tercer parámetro
colocamos el muelle, el cuarto parámetro es el borde derecho del segundo botón
que está en una disposición East, y el último parámetro es el
segundo botón.
Vamos a la última posición del muelle:
Esta posición va desde el borde derecho de la
lámina que está en la posición este al borde derecho del botón 3 que está en
una posición este:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0,
10, 100);
milayout.putConstraint(SpringLayout.WEST, boton1, mimuelle, SpringLayout.WEST, this);
milayout.putConstraint(SpringLayout.WEST, boton2, mimuelle, SpringLayout.EAST, boton1);
milayout.putConstraint(SpringLayout.WEST, boton3, mimuelle, SpringLayout.EAST, boton2);
milayout.putConstraint(SpringLayout.EAST,
this, mimuelle, SpringLayout.EAST, boton3);
}
El primer parámetro hace referencia al borde
de la esquina derecha de la lámina que está en una disposición este, el segundo
parámetro es el elemento que estamos trabajando que es la propia lámina y por
eso ponemos this, el tercer parámetro es la colocación del muelle,
el cuarto parámetro es el borde derecho del tercer botón que está en una
disposición east y el último parámetro el tercer botón.
Probamos:
Si redimensionamos la ventana vemos que los
botones se expanden y se contraen como si hubiera una especie de muelle virtual
entre ellos.
Si no queremos que los muelles del interior
no se estiren cuando redimensionemos la ventana, queremos que permanezcan
rígidos tenemos que utilizar el mismo método para crear el muelle pasándole un
parámetro, y en las posiciones del muelle que queremos que estén rígidos hacer
mención a esté segundo objeto, lo vemos en el código para verlo más claro:
public LaminaMuelle()
{
JButton boton1 = new JButton("Botón
1");
JButton boton2 = new JButton("Botón
2");
JButton boton3 = new JButton("Botón
3");
SpringLayout milayout = new SpringLayout();
setLayout(milayout);
add(boton1);
add(boton2);
add(boton3);
Spring mimuelle = Spring.constant(0,
10, 100);
Spring mimuelle_rigido = Spring.constant(10);
milayout.putConstraint(SpringLayout.WEST, boton1, mimuelle, SpringLayout.WEST, this);
milayout.putConstraint(SpringLayout.WEST, boton2, mimuelle_rigido, SpringLayout.EAST, boton1);
milayout.putConstraint(SpringLayout.WEST, boton3, mimuelle_rigido, SpringLayout.EAST, boton2);
milayout.putConstraint(SpringLayout.EAST, this, mimuelle, SpringLayout.EAST, boton3);
}
Os espero en el próximo post. Hasta
pronto!
8.3.1 Disposición en caja <<
>> 8.3.3 Disposición libre
No hay comentarios:
Publicar un comentario