INSTITUTO TECNOLÓGICO DE PARRAL

LAYOUT MANAGERS

M.C EDGAR OMAR BAÑUELOS LOZOYA

IBARRA QUINTANA LUIS ROMAN -13410180

QUINTANA MIGUEL OBED -13410189

OBJETIVO:

INVESTIGAR CONCEPTOS BÁSICOS DE LOS ADMINISTRADORES DE DISTRIBUCIÓN EN JAVA.

08 DE FEBRERO DE 2015

Índice

Descripción de la Actividad:...............................................................3

Layout Managers:................................................................................4

BorderLayout:.....................................................................................5

BoxLayout:..........................................................................................8

CardLayout:......................................................................................11

FlowLayout:.......................................................................................14

GridBagLayout:.................................................................................17

GridLayout:.......................................................................................21

GroupLayout:....................................................................................24

SpringLayout:....................................................................................28

Conclusiones:....................................................................................31

Bibliografía:........................................................................................32

Descripción de la Actividad:

Realizar una investigación de los siguientes Layout Managers:

BorderLayout BoxLayout CardLayout FlowLayout GridBagLayout GridLayout GroupLayout SpringLayout

De cada uno contemplar:

Nombre Características principales Ventajas Desventajas Constructores Mínimo dos ejemplos de código (con impresiones de pantalla que

demuestren su ejecución)

Layout Managers:

Los Layout Manager son componentes de software utilizados en juegos de herramientas de widgets que tienen la capacidad para diseñar elementos de control gráficos por sus posiciones relativas sin utilizar unidades de distancia. A menudo es más natural para definir los diseños de los componentes de esta manera de definir su posición en píxeles o unidades de distancia común, por lo que una serie de kits de herramientas de widgets populares incluyen esta capacidad por defecto.

Layout significa la disposición de los componentes dentro del contenedor. En otra forma podemos decir que la colocación de los componentes en una posición particular dentro del contenedor. La tarea del Layout se realiza automáticamente por el Layout Manager.

Los layout managers tienen una gran cantidad de ventajas:

Encapsulan parte de la lógica de presentación de nuestro interfaz gráfico de modo que evitan al programador tener que escribir una gran cantidad de líneas de código. Además hacen este código mucho más sencillo de leer y por lo tanto más mantenible.

Reorganizan automáticamente los componentes del interfaz de modo que siempre se ajuste a las directivas que hemos establecido previamente. Si el usuario en un momento dado decide maximizar el interfaz gráfico éste mantendrá su aspecto original en la medida de lo posible. De este modo no limitamos al usuario a un formato de pantalla determinado.

Hacen más sencillo la labor de añadir, modificar y eliminar componentes. Utilizando layout managers lo único que tenemos que hacer es agregar el componente y el layout manager se encarga automáticamente de reorganizar todo el interfaz.

Hacen nuestro interfaz mucho más portable. Esto se debe a que los componentes gráficos no tienen las mismas propiedades en todos los sistemas operativos.

Ciertamente existen también una serie de desventajas asociadas a los layout managers:

Requieren una buena dosis de aprendizaje y práctica. Muchos programadores odiarán los layout managers ya que pueden resultar una experiencia traumática sin un buen aprendizaje.

Pueden generar interfaces muy pesadas. A menudo las primeras veces que creemos nuestros layouts nos encontraremos con que acabamos con un gran número de paneles anidados. Los paneles son objetos bastante pesados por lo que hay que tener cuidado de no sobrecargar innecesariamente nuestra interfaz gráfica.

BorderLayout:

Divide el contenedor en 5 zonas (NORTH, SOUTH, EAST, WEST y CENTER) donde se añaden los componentes.

Por omisión se colocan en el centro.

Para añadir los componentes se utiliza el método:

add(Component compt, int zona)

“zona” puede tomar los valores BorderLayout.CENTER, BorderLayout.NORTH, BorderLayout.SOUTH, BorderLayout.WEST y BorderLayout.EAST

BorderLayout.NORTH 

BorderLayout.SOUTH 

BorderLayout.EAST 

BorderLayout.WEST 

BorderLayout.CENTER

Ventajas: BorderLayout, por su estructura, es muy útil para muchas aplicaciones. Por

ejemplo, sería bastante normal colocar una barra de herramientas en el panel norte de nuestra ventana, una barra de estado en el panel sur y quizás un árbol de navegación en el panel izquierdo o derecho, dejando el panel central para el resto del interfaz.

El constructor BorderLayout(int hgap, int vgap) nos permite especificar el espacio en pixeles.

Desventajas Por conveniencia si no especificamos ninguna de estas constantes el

componente se insertará en el centro del contenedor.

Constructores: BorderLayout()

Los componentes se colocan sin separación.

BorderLayout (int hGap, int VGAP) El diseño de la Frontera con los píxeles vacíos especificados entre

regiones. Componentes Adición:

Add (Componente, BorderLayout REGIÓN) Siempre especifique la región en la que agregar el componente.

Ejemplos utilizando BorderLayout:

import java.awt.BorderLayout;import javax.swing.JButton;import javax.swing.JFrame;

public class Bord1{ public static void main(String[] args) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setLayout(new BorderLayout(5,10)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); JButton boton4 = new JButton("Botón 4"); JButton boton5 = new JButton("Botón 5"); frame.add(boton1,BorderLayout.NORTH); frame.add(boton5,BorderLayout.SOUTH); frame.add(boton4,BorderLayout.EAST); frame.add(boton2,BorderLayout.WEST); frame.add(boton3,BorderLayout.CENTER); frame.setLocationRelativeTo(null); frame.setSize(700,400); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}

import java.awt.BorderLayout;import javax.swing.JButton;import javax.swing.JFrame;

public class Bord2{ public static void main(String[] args) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setLayout(new BorderLayout(15,15)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); frame.add(boton3,BorderLayout.SOUTH); frame.add(boton2,BorderLayout.EAST); frame.add(boton1,BorderLayout.WEST); frame.setLocationRelativeTo(null); frame.setSize(500,150); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}

BoxLayout:

Coloca sus componentes uno encima de otro (con el primer componente en la parte superior) o los sitúa en una fila de izquierda a derecha, según nuestra elección. Para crear una clase BoxLayout, se necesitan 2 argumentos: el objeto contenedor, y la clase que indica la forma de como ordenara los componentes

Ventajas:

FlowLayout ubica todos los componentes solo de forma horizontal, mientras que BoxLayout los ubica, tanto horizontal como vertical.

BoxLayout.X_AXIS —– Forma Horizontal

BoxLayout.Y_AXIS —– Forma Vertical

Es más completo que un FlowLayout.

Desventajas:

Para que los componentes salgan centrados (la etiqueta y el botón) hay que ir llamando uno por uno a su método.

Puedes probar a llamar a uno sí y a otro no, o a poner "alignment" distintos a cada uno. Conseguirás colocaciones verdaderamente extrañas.

Empalma los componentes si no los pone en orden (fila).

Constructor:

BoxLayout (Container objetivo, int eje)

Donde el parámetro entero eje puede tomar los valores:

X_AXIS, los componentes se organizan de izquierda a derecha y en horizontal.

Y_AXIS, los componentes se organizan de arriba a abajo y en vertical.

LINE_AXIS, los componentes se organizan como si estuviesen en una línea. Para ello se tiene en cuenta la propiedad ComponentOrientation del contenedor. Si esta propiedad es horizontal entonces los componentes se organizarán horizontalmente y además según su valor lo harán de izquierda a derecha o de derecha a izquierda. En otro caso se organizarán verticalmente de arriba abajo.

PAGE_AXIS, los componentes se organizan como si estuvieran en una página. Para ello se tiene en cuenta la propiedad ComponentOrientation del contenedor. Si esta propiedad es horizontal entonces los componentes se organizarán verticalmente y en otro caso lo harán horizontalmente.

Ejemplos utilizando BoxLayout:

import javax.swing.BoxLayout;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;

public class Box1{ public static void main(String[] args) { JFrame frame1 = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); JPanel panel1 = new JPanel(); panel1.setLayout(new BoxLayout(panel1, BoxLayout.X_AXIS)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); JButton boton4 = new JButton("Botón 4"); JButton boton5 = new JButton("Botón 5"); JButton boton6 = new JButton("Botón 6"); JButton boton7 = new JButton("Botón 7"); JButton boton8 = new JButton("Botón 8"); JButton boton9 = new JButton("Botón 9"); panel1.add(boton1); panel1.add(boton2); panel1.add(boton3); panel1.add(boton4); panel1.add(boton5); panel1.add(boton6); panel1.add(boton7); panel1.add(boton8); panel1.add(boton9); frame1.add(panel1); frame1.setLocationRelativeTo(null); frame1.setSize(750,100); frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame1.setVisible(true); }}

import javax.swing.BoxLayout;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;import java.awt.Component;

public class Box2{ public static void main(String[] args) { JFrame frame1 = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); JPanel panel1 = new JPanel(); panel1.setLayout(new BoxLayout(panel1, BoxLayout.Y_AXIS)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); JButton boton4 = new JButton("Botón 4"); JButton boton5 = new JButton("Botón 5"); boton1.setAlignmentX(Component.CENTER_ALIGNMENT); boton2.setAlignmentX(Component.CENTER_ALIGNMENT); boton3.setAlignmentX(Component.CENTER_ALIGNMENT); boton4.setAlignmentX(Component.CENTER_ALIGNMENT); boton5.setAlignmentX(Component.CENTER_ALIGNMENT); panel1.add(boton1); panel1.add(boton2); panel1.add(boton3); panel1.add(boton4); panel1.add(boton5); frame1.add(panel1); frame1.setLocationRelativeTo(null); frame1.setSize(500,180); frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame1.setVisible(true); }}

CardLayout:

Es un manejador de diseño que nos permite, ubicar componentes swing dentro de un mismo contenedor, y poder visualizarlos solamente uno a la vez. Este Layout es usado por los JTabbedPane, con la diferencia de la separación de los bordes de cada panel. Es decir, podemos tener un contenedor principal, y dentro de él, varios paneles, y a través de una selección, elegir cuál de estos paneles queremos que se visualice.

Ventajas:

Este layout manager es muy sencillo y muy útil especialmente cuando tenemos un panel que variará su contenido en función de alguna parte de nuestro interfaz (una Combo box por ejemplo).

En lugar de eliminar el panel e insertar otro nuevo, o en lugar de eliminar los componentes e insertar otros nuevos, podemos utilizar un CardLayout que nos ahorra gran cantidad de trabajo.

Desventajas:

El CardLayout hace que los componentes recibidos ocupen el máximo espacio posible

Sólo es visible uno de los componentes, los otros quedan detrás.

Constructores:

CardLayout()

CardLayout(int distancia_h, int distancia_v)

Ejemplos utilizando CardLayout:

import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class Card2 extends JFrame implements ItemListener { boolean inAnApplet = true; JPanel cards; final static String BUTTONPANEL = "JPanel with JButtons"; final static String TEXTPANEL = "JPanel with JTextField";

public Card2() {Container contentPane = getContentPane();

String comboBoxItems[] = { BUTTONPANEL, TEXTPANEL };

JPanel cp = new JPanel(); JComboBox c = new JComboBox(comboBoxItems);

c.setEditable(false); c.addItemListener(this); cp.add(c); contentPane.add(cp, BorderLayout.NORTH);

cards = new JPanel(); cards.setLayout(new CardLayout()); JPanel p1 = new JPanel(); p1.add(new JButton("Button 1")); p1.add(new JButton("Button 2")); p1.add(new JButton("Button 3"));

JPanel p2 = new JPanel(); p2.add(new JTextField("TextField", 20));

cards.add(BUTTONPANEL, p1); cards.add(TEXTPANEL, p2); contentPane.add(cards, BorderLayout.CENTER); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { if (inAnApplet) { dispose(); } else { System.exit(0); } } }); }

public void itemStateChanged(ItemEvent evt) { CardLayout cl = (CardLayout)(cards.getLayout()); cl.show(cards, (String)evt.getItem()); }

public static void main(String args[]) { Card2 window = new Card2(); window.inAnApplet = false;

window.setTitle("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); window.pack(); window.setVisible(true); }}

import java.awt.event.*;import javax.swing.*;import java.awt.*;

public class Card1 { public static void main(String[] args) { JFrame frame = new JFrame(); Container contenedor = frame.getContentPane(); JButton siguiente = new JButton("Siguiente"); final JPanel panel1 = new JPanel(); final CardLayout card = new CardLayout(); contenedor.setLayout(new BorderLayout()); contenedor.add(siguiente, BorderLayout.SOUTH); contenedor.add(panel1, BorderLayout.CENTER); JLabel a = new JLabel("Numero Uno :)"); JLabel b = new JLabel("Numero Dos :D"); JLabel c = new JLabel("Numero Tres :3"); panel1.setLayout(card); panel1.add(a); panel1.add(b); panel1.add(c); siguiente.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent i) { card.next(panel1); } }); frame.setTitle("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setSize(500, 100); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}

FlowLayout:

Acomoda los componentes de izquierda a derecha, hasta que se acaba la pantalla y entonces empieza en el siguiente renglón. Los componentes “fluyen” de izquierda a derecha, dejando, por omisión, un espacio vertical y horizontal de 5 píxeles entre sus componentes.

Es el administrador de diseño por defecto de la clase Panel, por ende de los applets.

Coloca los componentes de izquierda a derecha en una fila, según se van insertando en el contenedor, y cuando llega al borde del contenedor los sigue insertando en la siguiente fila.

Ventajas:

Deja un espacio de cinco puntos tanto horizontal como vertical entre componentes.

FlowLayout tiene varios constructores con los que podemos modificar este espaciado y también la alineación de los componentes.

El FlowLayout es bastante sencillo de usar

Es adecuado para barras de herramientas, filas de botones, etc.

Desventajas:

Si falta hueco, los componentes se partirán automáticamente en varias filas.

Ordena sus componentes de izquierda a derecha, y por ello debemos de poner más atención al introducir los datos para que los muestre como nosotros queramos, o indicar como los queremos ordenar.

Constructores:

FlowLayout(int alineación):

Modifica la disposición de los componentes. Los valores de alineación pueden ser FlowLayout.CENTER, FlowLayout.RIGHT y FlowLayout.LEFT.

FlowLayout(int alineación, int seph, int sepv):

Permite indicar la separación horizontal y vertical en píxeles.

FlowLayout(int alineación, int dist_h, int dist_v):

Especificar la alineación, así como el espacio horizontal y vertical entre componentes (en píxeles).

Ejemplos utilizando FlowLayout:

import java.awt.FlowLayout;import javax.swing.JButton;import javax.swing.JFrame;

public class Flow1{ public static void main(String[] args) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setLayout(new FlowLayout(FlowLayout.CENTER)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); JButton boton4 = new JButton("Botón 4"); JButton boton5 = new JButton("Botón 5"); JButton boton6 = new JButton("Botón 6"); JButton boton7 = new JButton("Botón 7"); JButton boton8 = new JButton("Botón 8"); JButton boton9 = new JButton("Botón 9"); frame.add(boton1); frame.add(boton2); frame.add(boton3); frame.add(boton4); frame.add(boton5); frame.add(boton6); frame.add(boton7); frame.add(boton8); frame.add(boton9); frame.setLocationRelativeTo(null); frame.setSize(500,120); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}

import javax.swing.JButton;import javax.swing.JCheckBox;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JTextField;

public class Flow2{ public static void main(String[] args) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setLayout(new FlowLayout(FlowLayout.RIGHT)); frame.add(new JLabel("Etiqueta número 1")); frame.add(new JButton("Botón 2")); frame.add(new JCheckBox("CheckBox 3")); frame.add(new JTextField("Entrada larga de Texto 4 ")); frame.add(new JButton("Botón 5")); frame.setLocationRelativeTo(null); frame.setSize(485,120); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); }}

GridBagLayout:

Es un contenedor flexible que alinea los componentes vertical y horizontalmente, sin la necesidad de que los componentes sean del mismo tamaño. Los objetos GridBagLayout tienen una cuadrícula dinámica en la cual un componente puede ocupar más de una celda. Es el layout manager más poderoso y eficaz con mucha diferencia. Con GridBagLayout podemos imitar fácilmente el comportamiento del resto de layout managers aparte de poder crear con el interfaces mucho más complejas.

Ventajas:

Permite la creación de interfaces de usuario complejos. Con este layout manager tenemos control absoluto sobre las posiciones que ocuparán los objetos en el interfaz final.

Las interfaces construidas son más ligeras. Cuando queremos crear un interfaz de usuario combinando el resto de layout managers a menudo terminamos con un número grande de paneles anidados. Los paneles son objetos bastante pesados y tener una gran cantidad de los mismos puede influir perjudicialmente en el rendimiento de nuestro programa. Con GridBagLayout se pueden crear interfaces exactamente iguales pero con un único panel con lo que nuestra interfaz será mucho más ligera.

Desventajas:

Requiere un tiempo de aprendizaje bastante grande. No sólo es necesario comprender su funcionamiento sino que también es necesario haber hecho bastantes ejemplos para llegar a dominarlo.

El código necesario para crear un interfaz de usuario es considerablemente más grande que con el resto de layout managers y además suele ser un código bastante complicado y difícil de comprender y por lo tanto de mantener.

Constructor:

GridBagLayout basa su funcionamiento en una clase auxiliar que establece restricciones a los componentes, GridBagConstraints. Estas restricciones especifican exactamente como se mostrará cada elemento dentro del contenedor.

Las propiedades son:

anchor: Posición del componente dentro de la celda: NORTH, NORTHWEST, CENTER, etc.

insets (int top, int left, int bottom, int right): es el margen que tienen los componentes dentro de la celda.

gridx: Columna en la cual se pone al componente. gridy: Fila en la cual se pone al componente. gridwidth: Número de columnas que un componente ocupa (REMAINDER:

todas las que restan). gridheight: Número de filas que un componente ocupa. (REMAINDER).

Ejemplos utilizando GridBagLayout:

import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class GridBag1 extends JFrame { boolean inAnApplet = true; final boolean shouldFill = true; final boolean shouldWeightX = true; public GridBag1() { JButton button; Container contentPane = getContentPane(); GridBagLayout gridbag = new GridBagLayout(); GridBagConstraints c = new GridBagConstraints(); contentPane.setLayout(gridbag); if (shouldFill) { c.fill = GridBagConstraints.HORIZONTAL; } button = new JButton("Botón 1"); if (shouldWeightX) { c.weightx = 0.5; } c.gridx = 0; c.gridy = 0; gridbag.setConstraints(button, c); contentPane.add(button);

button = new JButton("2"); c.gridx = 1; c.gridy = 0; gridbag.setConstraints(button, c); contentPane.add(button);

button = new JButton("Botón 3"); c.gridx = 2; c.gridy = 0; gridbag.setConstraints(button, c); contentPane.add(button);

button = new JButton("Botón 4"); c.ipady = 40;

c.weightx = 0.0; c.gridwidth = 3; c.gridx = 0; c.gridy = 1; gridbag.setConstraints(button, c); contentPane.add(button);

button = new JButton("Botón 5"); c.ipady = 0; c.weighty = 1.0; c.anchor = GridBagConstraints.SOUTH; c.insets = new Insets(10,0,0,0); c.gridx = 1; c.gridwidth = 2; c.gridy = 2; gridbag.setConstraints(button, c); contentPane.add(button);

addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { if (inAnApplet) { dispose(); } else { System.exit(0); } } }); }

public static void main(String args[]) { GridBag1 window = new GridBag1(); window.inAnApplet = false;

window.setTitle("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); window.pack(); window.setVisible(true); }}

import java.awt.*;import javax.swing.*;

public class GridBag2 {

public static void main(String[] args){ JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setSize(500,200); JPanel panel = new JPanel(); GridBagLayout layout = new GridBagLayout(); panel.setLayout(layout); GridBagConstraints gbc = new GridBagConstraints();

gbc.fill = GridBagConstraints.HORIZONTAL; gbc.gridx = 0; gbc.gridy = 0; panel.add(new JButton("Botón 1"),gbc);

gbc.gridx = 1; gbc.gridy = 0; panel.add(new JButton("Botón 2"),gbc);

gbc.fill = GridBagConstraints.HORIZONTAL; gbc.ipady = 20; gbc.gridx = 0; gbc.gridy = 1; panel.add(new JButton("Botón 3"),gbc);

gbc.gridx = 1; gbc.gridy = 1; panel.add(new JButton("Botón 4"),gbc);

gbc.gridx = 0; gbc.gridy = 2; gbc.fill = GridBagConstraints.HORIZONTAL; gbc.gridwidth = 2; panel.add(new JButton("Botón 5"),gbc); frame.add(panel); frame.setVisible(true); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}

GridLayout:

GridLayout divide el espacio de un contenedor en forma de tabla, es decir, en un conjunto de filas y columnas. Cada fila y cada columna tiene el mismo tamaño y el área del contenedor se distribuye equitativamente entre todas las celdas. De todo esto se deduce que GridLayout no respetará el tamaño preferido de los componentes que insertemos en cada una de las celdas. Los componentes se agregan de izquierda a derecha y de arriba hacia abajo.

Ventajas:

Es un layout manager realmente muy simple y como tal su utilidad se encuentra bastante reducida. Suele ser útil a la hora de crear partes del interfaz de usuario que necesiten representar una matriz de componentes o incluso para interfaces que tengan en si una forma matricial.

Desventajas:

No permite tener tamaños diferentes en las celdas, ni que una celda ocupe varias posiciones, además de que no se pueden dejar celdas vacías. Su utilidad se encuentra bastante reducida.

Constructores:

GridLayout():

Crea una sola fila con una columna asignada por componente

GridLayout(int filas, int columnas):

Divide la ventana en el número especificado de filas y columnas

GridLayout(int filas, int columnas, int dist_h, int dist_v):

Utiliza las brechas especificadas entre células.

Ejemplos utilizando GridLayout:

import java.awt.GridLayout;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JPanel;

public class Grid1{ public static void main(String[] args) { JFrame frame1 = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); JPanel panel1 = new JPanel(); panel1.setLayout(new GridLayout(2,4)); JButton boton1 = new JButton("Botón 1"); JButton boton2 = new JButton("Botón 2"); JButton boton3 = new JButton("Botón 3"); JButton boton4 = new JButton("Botón 4"); JButton boton5 = new JButton("Botón 5"); JButton boton6 = new JButton("Botón 6"); JButton boton7 = new JButton("Botón 7"); JButton boton8 = new JButton("Botón 8"); JButton boton9 = new JButton("Botón 9"); panel1.add(boton1); panel1.add(boton2); panel1.add(boton3); panel1.add(boton4); panel1.add(boton5); panel1.add(boton6); panel1.add(boton7); panel1.add(boton8); panel1.add(boton9); frame1.add(panel1); frame1.setLocationRelativeTo(null); frame1.setSize(500,250); frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame1.setVisible(true); }}

import java.awt.GridLayout;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JTextArea;

public class Grid2 {

public static void main(String[] args) { JButton[] arregloBtn; JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(500, 500); frame.setLayout(new GridLayout(5, 3, 10, 10)); JTextArea texto = new JTextArea();

texto.setText("Resultado"); texto.setEditable(false); frame.add(texto);

frame.add(new JButton("+")); frame.add(new JButton("=")); arregloBtn = new JButton[10]; for(int i=0; i < arregloBtn.length; i++) { arregloBtn[i] = new JButton(Integer.toString(i)); frame.add(arregloBtn[i]);} frame.setVisible(true);}

}

GroupLayout:

El GroupLayout destaca entre los demás administradores de despliegue porque nos permite establecer de manera precisa la posición y el tamaño de cada componente dentro del contenedor.

La clase GroupLayout requiere de los métodos setHorizontalGroup y setVerticalGroup para definir la ubicación y las dimensiones de los componentes. Para utilizar estos métodos es importante que sepan la función de los objetos de tipo SequentialGroup y los objetos de tipo ParallelGroup.

Un objeto de tipo SequentialGroup representa un grupo cuyo contenido está acomodado en secuencia. Mientras que un objeto de tipo ParallelGroup representa un grupo cuyo contenido está acomodado en paralelo.

Ventajas:

Se pueden agrupar los componentes. Acomoda de manera secuencial los elementos (uno tras otro).

Desventajas.

Se le tienen que dar los ejes para que los pueda representar.

Constructor:

GroupLayout (Container host): Crea un GroupLayout para el contenedor especificado.

Ejemplos utilizando GroupLayout:

import java.awt.*;import javax.swing.*;

public class Group1 { public static void main(String[] args) { JLabel label = new JLabel("Cual equipo perdera la categoria:"); JSeparator separator = new JSeparator(JSeparator.HORIZONTAL);

DefaultListModel model = new DefaultListModel(); model.addElement("Guadalajara"); model.addElement("Leones Negros"); model.addElement("Puebla"); model.addElement("Veracruz");

JList list = new JList(model); list.setPreferredSize(new Dimension(250, 200));

JScrollPane scrollPane = new JScrollPane(); scrollPane.setViewportView(list);

JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

Container contentPane = frame.getContentPane(); GroupLayout layout = new GroupLayout(contentPane); layout.setAutoCreateContainerGaps(true); contentPane.setLayout(layout);

layout.setHorizontalGroup( layout.createParallelGroup(GroupLayout.Alignment.LEADING) .addComponent(label, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE, Short.MAX_VALUE) .addComponent(separator) .addComponent(scrollPane) ); layout.setVerticalGroup( layout.createSequentialGroup() .addComponent(label) .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED) .addComponent(separator, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE, Short.MAX_VALUE) .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED) .addComponent(scrollPane, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE, Short.MAX_VALUE) ); frame.pack(); frame.setLocationRelativeTo(null); frame.setVisible(true);}}

import javax.swing.*;import static javax.swing.GroupLayout.Alignment.*;

public class Group2 extends JFrame { public Group2() { JLabel label = new JLabel("Buscar:");; JTextField textField = new JTextField(); JCheckBox caseCheckBox = new JCheckBox("Opción 1"); JCheckBox wrapCheckBox = new JCheckBox("Opción 2"); JCheckBox wholeCheckBox = new JCheckBox("Opción 3"); JCheckBox backCheckBox = new JCheckBox("Opción 4"); JButton findButton = new JButton("Encontrar"); JButton cancelButton = new JButton("Cancelar"); caseCheckBox.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0)); wrapCheckBox.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0)); wholeCheckBox.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0)); backCheckBox.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));

GroupLayout layout = new GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setAutoCreateGaps(true); layout.setAutoCreateContainerGaps(true);

layout.setHorizontalGroup(layout.createSequentialGroup() .addComponent(label) .addGroup(layout.createParallelGroup(LEADING) .addComponent(textField) .addGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(LEADING) .addComponent(caseCheckBox) .addComponent(wholeCheckBox)) .addGroup(layout.createParallelGroup(LEADING) .addComponent(wrapCheckBox) .addComponent(backCheckBox)))) .addGroup(layout.createParallelGroup(LEADING) .addComponent(findButton) .addComponent(cancelButton)) ); layout.linkSize(SwingConstants.HORIZONTAL, findButton, cancelButton);

layout.setVerticalGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(BASELINE) .addComponent(label) .addComponent(textField) .addComponent(findButton)) .addGroup(layout.createParallelGroup(LEADING) .addGroup(layout.createSequentialGroup() .addGroup(layout.createParallelGroup(BASELINE) .addComponent(caseCheckBox) .addComponent(wrapCheckBox)) .addGroup(layout.createParallelGroup(BASELINE) .addComponent(wholeCheckBox) .addComponent(backCheckBox))) .addComponent(cancelButton))

);

setTitle("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); pack(); setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); } public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { try { UIManager.setLookAndFeel( "javax.swing.plaf.metal.MetalLookAndFeel"); // "com.sun.java.swing.plaf.motif.MotifLookAndFeel"); //UIManager.getCrossPlatformLookAndFeelClassName()); } catch (Exception ex) { ex.printStackTrace(); } new Group2().setVisible(true); } }); }}

SpringLayout:

SpringLayout define los componentes que estarán dentro del interfaz y la relación entre estos componentes, es decir, el espacio que habrá entre ellos. SpringLayout intentará respetar siempre que pueda el tamaño preferido de los componentes.

El espacio entre los componentes se define utilizando objetos Spring. Cada objeto Spring tiene cuatro propiedades, sus tamaños máximo, mínimo y preferido junto con su tamaño actual. Todos estos objetos Spring se acumulan formando un conjunto de restricciones que estarán en un objeto de tipo SpringLayout.Constraints.

Ventajas:

Que trabaja con coordenadas para ubicar los bordes.

Desventajas.

Trabaja con hilos para marcar las distancias entre cada borde.

Todavía no existe la suficiente documentación sobre este layout manager salvo lo poco que se puede encontrar en el tutorial de SUN y que parece que ni siquiera ellos saben cómo funciona.

Constructores:

SpringLayout.Constraints()

SpringLayout.Constraints(spring, spring)

SpringLayout.Constraints (spring, spring, spring, spring)

Los dos primeros argumentos, si está presente, especifican los resortes X e Y, respectivamente. Los otros dos argumentos, si está presente, especifican los resortes alto y ancho, respectivamente. La omisión de un argumento hace que el correspondiente resorte sea nula, que SpringLayout generalmente reemplaza con valores predeterminados adecuados.

Ejemplos utilizando SpringLayout:

import java.awt.Component;import java.awt.Container;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JTextField;import javax.swing.SpringLayout;

public class Spring1{ public static void main(String args[]) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); Container contentPane = frame.getContentPane();

SpringLayout layout = new SpringLayout(); contentPane.setLayout(layout);

Component left = new JLabel("Ingresa tu nombre:"); Component right = new JTextField(30); frame.setLocationRelativeTo(null);

contentPane.add(left); contentPane.add(right); layout.putConstraint(SpringLayout.WEST, left, 10, SpringLayout.WEST, contentPane); layout.putConstraint(SpringLayout.NORTH, left, 25, SpringLayout.NORTH, contentPane); layout.putConstraint(SpringLayout.NORTH, right, 25, SpringLayout.NORTH, contentPane); layout.putConstraint(SpringLayout.WEST, right, 20, SpringLayout.EAST, left);

frame.setSize(500, 120); frame.setVisible(true); }}

import javax.swing.*; public class Spring2{ public static void main(String[] args) { JFrame frame = new JFrame("Luis Roman Ibarra Quintana - Miguel Obed Quintana"); JLabel label1 = new JLabel("Usuario:"); JTextField textField1 = new JTextField("", 15); JLabel label2 = new JLabel("Organización:"); JTextField textField2 = new JTextField("", 15); SpringLayout layout = new SpringLayout(); frame.getContentPane().setLayout(layout); frame.getContentPane().add(label1); frame.getContentPane().add(textField1); frame.getContentPane().add(label2); frame.getContentPane().add(textField2); layout.putConstraint(SpringLayout.WEST, label1, 10, SpringLayout.WEST, frame.getContentPane()); layout.putConstraint(SpringLayout.NORTH, label1, 10, SpringLayout.NORTH, frame.getContentPane()); layout.putConstraint(SpringLayout.WEST, textField1, 10, SpringLayout.EAST, label1); layout.putConstraint(SpringLayout.NORTH, textField1, 10, SpringLayout.NORTH, frame.getContentPane()); layout.putConstraint(SpringLayout.WEST, label2, 10, SpringLayout.WEST,frame.getContentPane()); layout.putConstraint(SpringLayout.NORTH, label2, 30, SpringLayout.NORTH, frame.getContentPane()); layout.putConstraint(SpringLayout.WEST, textField2, 10, SpringLayout.EAST, label2); layout.putConstraint(SpringLayout.NORTH, textField2, 30, SpringLayout.NORTH, frame.getContentPane()); frame.setSize(500,120); frame.setVisible(true); frame.setLocationRelativeTo(null); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }}

Conclusiones:

En esta actividad que realizamos aprendimos acerca de los diferentes tipos de Layout Managers (Administradores de Distribución) como su concepto y sus características, además de ejemplificar cada uno de ellos para poder entenderlos mejor. Fue muy interesante la actividad ya que tuvimos que poner en práctica el trabajo en equipo para obtener resultados positivos cada uno de nosotros poniendo de su parte para poder terminar lo más pronto posible.

Algunos de los contratiempos que se nos presentaron fueron debido a que en los sitios donde buscamos la información no venían de manera muy explícita además la mayoría venían en inglés, así mismo batallamos con los ejemplos de los Layouts.

Mi opinión acerca de esta actividad es muy buena nomas que a un miembro del equipo le surgieron contratiempos por lo que tuvimos que empeñarnos toda la noche de sábado para realizarla porque el envió es hasta las 9 de la mañana y eso nos hizo tener que trabajar más duro.

Para poder llevar acabo esta actividad invertimos un tiempo de 12 horas entre la investigación y la redacción del documento.

Bibliografía:

http://claroline.ucaribe.edu.mx/claroline/claroline/backends/download.php? url=L1NFTUFOQV8xMS9sYXlvdXRzLnBkZg%3D%3D&cidReset=true&cidReq=TECM2012

http://www.academica.mx/sites/default/files/adjuntos/13274/Como %20programar%20en%20Java%20-%207ma%20Edicion%20-%20P.%20J.%20Deitel.pdf

http://yaqui.mxl.uabc.mx/~curlango/pooi/Apuntes04-1.pdf http://fcqi.tij.uabc.mx/usuarios/palacios/java7.pdf http://www.java-programming.info/tutorial/pdf/java/11-Java-Layout-

Managers.pdf http://www.myjavazone.com/2011/02/manejadores-de-contenido-

cardlayout.html http://www.academica.mx/sites/default/files/adjuntos/13274/Como

%20programar%20en%20Java%20-%207ma%20Edicion%20-%20P.%20J.%20Deitel.pdf

http://www.sc.ehu.es/sbweb/fisica/cursoJava/applets/diseno/flow.htm http://proton.ucting.udg.mx/tutorial/java/Cap4/glayout.html http://docs.oracle.com/javase/7/docs/api/javax/swing/

GroupLayout.html#GroupLayout(java.awt.Container)