CONTENEDORES EN JAVA

CONTENEDORES

Botones

Los botones son de las herramientas principales en cualquier aplicación gráfica, la clase encargada de los botones es JButton, un botón es un contenedor que puede tener tanto una imagen, texto o ambos, dentro de el.Las formas para crear un botón son:

JButton(String texto);
JButton(Icon icono);
JButton(String texto, Icon icono);

La primera opción crea un botón con sólo texto (como lo hemos utilizado), la segunda opción crea un botón con texto e imagen, por ejemplo:

Jbutton boton = JButton("Guardar", new ImageIcon("save.jpg"));

Esto creará un botón como el siguiente:

figura

Los botones responden principalmente a actionListener (aunque obviamente también pueden responder a focusListener), y el método actionPerformed de la interfaz actionListener, corresponde a la acción de presionar el botón.

Algunos métodos importantes de la clase JButton son:

Valor de Retorno	Nombre del Método
void	setText(String texto)
	cambia el texto al botón.
String	getText()
	Obtiene el texto del Botón.
void	setIcon(Icon icono)
	cambia el ícono al botón.
Icon	getIcon()
	Obtiene el ícono del Botón.

Existe una clase similar a Button (de hecho forman parte de la clase abstracta AbstractButton) llamada JToggleButton que permite tener la funcionalidad de botones presionados, un ejemplo de esto, son los botones de Negrita, Cursiva, 

Subrayado en los editores de texto comunes.

El JToggleButton es muy similar a JButton de hecho sus constructores son muy parecidos:

JToggleButton(String texto);
JToggleButton(Icon icono);
JToggleButton(String texto, Icon icono);

Un método de los componentes que nos será de utilidad será la de setName(String nombre) este método nos permite darle un nombre (mejor dicho cambiarlo) interno al componente, así por ejemplo si tenemos dos botones, ambos con el mismo nombre (aunque en princpio esto da a lugar a ambigüedades) para diferenciarlos podemos darles nombres internos, con los cuales los reconoceremos dentro del programa, gracias al método setName.

Etiquetas

Las etiquetas nos permiten mostrar información o mostrar una imagen:

JLabel(String texto);
JLabel(String texto, int posicion_horizontal);
JLabel(Icon imagen);
JLabel(Icon imagen, int posicion_horizontal);
JLabel(String texto, Icon imagen, int posicion_horizontal);

Al igual que JButton tenemos métodos para cambiar las etiquetas:

Valor de Retorno	Nombre del Método
void	setText(String texto)
	cambia el texto de la etiqueta.
String	getText()
	Obtiene el texto de la etiqueta.
void	setIcon(Icon icono)
	cambia el ícono de la etiqueta.
Icon	getIcon()
	Obtiene el ícono de la etiqueta.

Un método que es útil para fines estéticos es el de setFont(Font), el cuál es de la clase JComponent y funciona para todos los componentes que desplieguen texto.

compomente.setFont(Font f);
Font f = new Font(String nombre_fuente, int estilo, int tamano);

Cajas de Texto
Las cajas de texto permiten introducir información de parte del usuario, son parte también de los componentes más utilizados existen dos tipos de Cajas de Texto las cajas de texto de una sóla línea y las cajas de texto de varias líneas, las primeras son conocidas como: JTextField y las segundas como JTextArea.
JTextField();
JTextField(int columnas);
JTextField(String texto_inicial);
JTextField(String texto_inicial, int columnas);

JTextArea();
JTextArea(int columnas, int filas);
JTextArea(String texto_inicial);
JTextArea(String texto_inicial, int columnas, int filas);


figura

Los métodos importantes para JTextField son:


Valor de Retorno
Nombre del Método
int
getColumns()
Obtiene el tamaño de la caja de texto.
int
getColumnWidth()
Obtiene número de caracteres introducidos.
void
setFont(Font fuente)
cambia la fuente.
void
setColumns(int columnas)
Establece el ancho de la caja de texto.



Y para JTextArea:


Valor de Retorno
Nombre del Método
void
append(String cadena)
Agrega al final del área de texto cadena.
void
insert(String cadena, int pos)
Agrega la cadena. después de pos
int
getColumns()
Obtiene el tamaño de la caja de texto.
int
getColumnWidth()
Obtiene número de caracteres introducidos.
int
getLineCount()
Obtiene número de líneas.
void
setFont(Font fuente)
cambia la fuente.
void
setColumns(int columnas)
Establece el ancho del área de texto.
void
setRows(int filas)
Establece las filas del área de texto.



Las cajas de texto tienen propieadades interesantes como son:


Valor de Retorno
Nombre del Método
void
cut()
Corta el texto.
void
copy()
Copia el texto.
void
paste()
Pega el texto
void
select(int inicio, int final)
Selecciona el texto desde la posición inicio hasta la posición final.
void
selectAll()
Selecciona todo el texto.
void
setSelectedTextColor(Color c)
Asigna el color para el texto seleccionado.
void
setSelectionColor(Color c)
Asigna el color para la selección.
void
setSelectionStart(int inicio)
Indica donde debe comenzar la selección.
void
setSelectionEnd(int final)
Indica donde debe finalizar la selección.








Cuadros de Diálogos
Los cuadros de diálogo proveen otro tipo de interacción con el usuario, los cuadros de diálogo más comunes son los de confirmación:figura

Se confirman acciones como borrado, actualización, etc., pero en si un cuadro de diálogo puede tratarse como otra ventana, excepto con una propiedad: El Modal, el modal permite que si se abre un cuadro de diálogo, la ventana que lo creó no pueda ser accesada hasta que el usuario cierre el cuadro de diálogo, esto puede ser muy importante cuando tenemos que confirmar algo antes de que el usuario pueda utilizarlo (por ejemplo, que inicie una sesión dando su nombre de usuario y contraseña), o que el cuadro de diálogo permanezca abierto sin que interfiera con la ventana padre (puede estar desplegando información útil al usuario pero no necesaria para el correcto funcionamiento del programa).

Para crear un cuadro de diálogo:

JDialog dialogo = new JDialog(ventana_padre, "Dialogo", yes);
... /*Agregarle al dialogo algunos componentes*/
/*Necesitamos agregarle un manejador de eventos como 
cualquier otra ventana*/
dialogo.addWindowListener(WindowListener al);
dialogo.setSize(200,300); /*En caso de ser necesario*/
dialogo.setVisible(true); /*Funciona como una ventana, el dialogo
                           * existira, pero no sera mostrado.
                           */
...

Dentro de los métodos más usados para los diálogos, están la posibilidad de poner el modal, y el de permitir que se cambie su tamaõ:


Valor de Retorno
Nombre del Método
void
setModal(boolean modal)
Cambia el modal con el valor booleano modal
void
setResizable(boolean resize)
Permite cambiar de tamaño la ventana.
boolean
getModal()
Obtiene el valor de modal que tiene asignada la ventana

Nota Si se ejecuta simplmente el método setModal no cambiará en nada el modal real, por lo que hay que ocultar el diálogo, cambiar el modal y después volverlo a mostrar y el modal será asignado correctamente.

Hay que aclarar, que puede parecer sencillo, asignarle el mismo objeto WindowListener que usamos para la ventana padre, pero el problema es que la ventana padre termina la ejecución, aparte de liberar recursos.

Es mejor utilizar un WindowListener apropiado que en el método windowClosing no termine la aplicación, sino que haga uso del método dispose.

Por ejemplo:

/*Extenderla de WindowAdapter que es una clase abstracta
que implementa a WindowListener, y asi evitamos implementar
todos los m\'etodos de WindowListener.
*/
public class CerrarDialogo extends WindowAdapter
{
    public void windowClosing(WindowEvent evt)
    {
       evt.getWindow().dispose();  
    }
}





Listas
Swing proporciona las Listas para poder seleccionar datos de entre una serie de posibilidades.Una lista puede ser construida ya sea de un arreglo de datos (de tipo Object) o de un objeto Vector.

La clase JList es creada mediante alguno de estos dos métodos:

new JList(Object[] datos);
new JList(Vector datos);

Entre los métodos más utilizados para la lista son:


Valor de Retorno
Nombre del Método
void
setSelectionMode(int modo)
Determina si la seleccion será. (determinada por modo)
ListSelectionModel.SINGLE_SELECTION
Sólo selecciona un valor
ListSelectionModel.SINGLE_INTERVAL_SELECTION
Selecciona varios valores, pero que sean contiguos
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION
Selecciona varios valores, sin depender de la contiguidad
Object
getSelectedValue()
Retorna el valor seleccionado.
Object[]
getSelectedValues()
Retorna los valores seleccionado.
int
getSelectedIndex()
Obtiene el índice seleccioando.
int[]
getSelectedIndices()
Obtiene los índices seleccioandos.
void
setSelectedIndex(int indice)
Selecciona el índice de la lista
void
setSelectedIndices(int indices[])
Selecciona los índices de la lista
void
setSelectedValue(Object elemento)
selecciona el elemento de la lista

La lista sólo se le puede asignar un evento que proviene del paquete javax.swing.event el cuál es el de ListSelectionListener que sólo tiene un método: 
public void valueChanged(ListSelectionEvent e) 
Que funciona para saber cuándo un elemento ha sido seleccionado.

Y se registra con: addListSelectionListener(ListSelectionListener listener)






JComboBox
los JComboBox son muy parecidos a las Listas, excepto que estos también permiten la introducción de los datos, las maneras para crear son muy similares a las de JList:

new JComboBox();
new JComboBox(Object[] datos);
new JComboBox(Vector datos);

Lo métodos son:


Valor de Retorno
Nombre del Método
void
addItem(Object item)
Agrega un elemento al combo
Object
getSelectedItem()
Retorna el valor seleccionado.
int
getSelectedIndex()
Obtiene el índice seleccioando.
void
setEditable(boolean tipo)
Determina si sólo mostrara los valores (false) o si se
pueden escribir nuevos valores (true)

Y al igual que que JList, tiene un Listener que es: ItemListener que sólo implementa un método: public void itemStateChanged(ItemEvent e) que se realiza cuando se cambia a un item.

El registro del Listener se realiza con el método addItemListener de la clase JComboBox






CheckBoxes
Los JCheckBox permite tener botones que pueden ser seleccionados como verdadero o falso.

Se parece mucho a un JButton en la manera de iniciar:

new JCheckBox(String texto);
new JCheckBox(String texto, boolean seleccionado);
new JCheckBox(Icon icono, String texto);
new JCheckBox(Icon icono, String texto, boolean seleccionado);
new JCheckBox(Icon icono);
new JCheckBox(Icon icono, boolean seleccionado);

El manejador de eventos es el de addActionListener para cuando se presione sobre un botón.








JRadioButton
Los botones de radio son útiles cuando seleccionamos entre algunos valores (que no son tantos como para ponerlos en una lista, o en un JComboBox), por ejemplo seleccionar entre Masculino y Femenino ya que un checkbox podría llegar a ser confuso.

Los botones de radio, se inicializan como cualquier boton:

new JRadioButton(String texto);
new JRadioButton(String texto, boolean seleccionado);
new JRadioButton(Icon icono, String texto);
new JRadioButton(Icon icono, String texto, boolean seleccionado);
new JRadioButton(Icon icono);
new JRadioButton(Icon icono, boolean seleccionado);

Salvo que hay que agregarlos todo a un ButtonGroup para que todos los botones de radio de ese grupo sean entre los que se puedan seleccionar.

new ButtonGroup();

y el método importante es:

add(AbstractButton boton);

Además hay que agregar a cada botón de radio, un ActionListener para saber cuál ha sido seleccionado.








Menús
Para agregar el menú que ya conocemos a una ventana instancia JFrame basta crear una objeto de tipo JMenuBar y con el método setJMenuBar(menuBar) de JFrame lo insertamos en la ventana; o si lo prefiere, con el métodogetContentPane().add(Component) podemos agregarlo en la posición que queramos. Un JMenuBar se compone de un conjunto de Menús instancias de JMenu. Cada JMenu se compone de elementos (item) que pueden ser instancias de JMenuItem (los elementos que se pueden seleccionar en el menú) y de instancias de JMenu (en caso de que se quiera un submenú). Para que se vea más claro veamos el siguiente ejemplo que crea los menú clásico de Archivo y Edicion

import javax.swing.*;
import java.awt.event.*;
public class SimpleMenu {
   public static JMenuBar creaMenu() { 
      JMenuBar menubar = new JMenuBar();
      JMenu menu = new JMenu("Archivo");
      JMenuItem item = new JMenuItem("Abrir");
      menu.add(item);
      item = new JMenuItem("Salir");
      menu.add(item);
      menubar.add(menu);
      menu = new JMenu("Edicion");
      item = new JMenuItem("Cortar");
      menu.add(item);
      item = new JMenuItem("Copiar");   
      menu.add(item);
      menubar.add(menu);
      return menubar; 
   }
   public static void main(String[] pars) {
      JFrame frame = new JFrame("Ejemplo simple de un menu");
      frame.setJMenuBar(creaMenu());
      frame.setSize(400, 300);
      frame.addWindowListener(new WindowAdapter() {
         public void windowClosing(WindowEvent we) {
            System.exit(0);
         }
      });
      frame.setVisible(true);   
   }
}






Figura: Jerarquía de la clase JMenuItem






Como se puede observar en la figura anterior los items de menús son simples botones, y por lógica, los eventos que actúa sobre cada item se manejan igual que los botones. Además hay que observar que existe el JCheckboxMenuItem yJRadioButtonMenuItem lo cual son items de los menús, que tienen la misma apariencia que los checkbox clásicos y el RadioButton, respectivamente.Y por si fuera poco se utilizan de la misma forma.








Menús emergentes
Por lo regular los menús emergentes se despliegan normalmente cuando presionamos el botón derecho del mouse sobre cierto componente, si es así, para crear uno es necesario agregar un listener del ratón a el(los) componente(s) que queremos que se vea(n) afectado por dicha situación. El menú que aparece no es una instancia de JMenu, sino una de JPopupMenu, y se le agregan los elementos de la misma forma que a un JMenu. Este sería el código para crear una instancia de JPopupMenu con las opciones {Azul, Verde, Rojo}.

JPopupMenu popup = new JPopupMenu();
JMenuItem menuItem = new JMenuItem("Azul");
popup.add(menuItem);
menuItem = new JMenuItem("Verde");
popup.add(menuItem);
menuItem = new JMenuItem("Rojo");
popup.add(menuItem);

Ahora para el manejo del evento del mouse, una implementación sencilla sería la siguiente:

class PopupListener extends MouseAdapter {
    public void mousePressed(MouseEvent e) {
        maybeShowPopup(e);
    }
    public void mouseReleased(MouseEvent e) {
        maybeShowPopup(e);
    }
    private void maybeShowPopup(MouseEvent e) {
        if (e.isPopupTrigger()) {
            popup.show(e.getComponent(), e.getX(), e.getY());
        }
    }
}

Ahora, a cualquier componente que queramos que tenga su menú emergente basta agregarle una instancia de la clase creada antes para el manejo del evento del mouse(). El código necesario es el siguiente:

MouseListener popupListener = new PopupListener();
component.addMouseListener(popupListener);