173840-Programaci N GR Fica Con Swing Emmanuel Rivera

12.
Programacin Grfica Con Swing

M.C. Emmanuel Zenn Rivera Blas Pgina 1
Contenido
PROGRAMACIN GRFICA CON SWING ............................................................................... 3
CARACTERISTICAS DE SWING ................................................................................................ 4
JERARQUA DE COMPONENTES DEL SWING ....................................................................... 5
COMPONENTES ............................................................................................................................ 9
EVENTOS ....................................................................................................................................... 9
Qu es un evento? .................................................................................................................... 10
El modelo de delegacin de eventos.......................................................................................... 10
Tipos de Eventos ....................................................................................................................... 14
Origen de eventos ...................................................................................................................... 16
Adapters ..................................................................................................................................... 19
COMPONENTES ATMICOS DEL SWING ............................................................................. 24
JButton ....................................................................................................................................... 24
JCheckBox ................................................................................................................................. 24
JRadioButton ............................................................................................................................. 26
JList ........................................................................................................................................... 29
JComboBox ............................................................................................................................... 31
JLabel ........................................................................................................................................ 32
JTextField y JPasswordField ..................................................................................................... 33
JTextArea................................................................................................................................... 36
CUADROS DE DIALOGO ESTNDAR .................................................................................... 38
JOptionPane ............................................................................................................................... 38
JFileChooser .............................................................................................................................. 43
JColorChooser ........................................................................................................................... 45
LAYOUTS .................................................................................................................................... 47
FlowLayout ................................................................................................................................ 48
BorderLayout ............................................................................................................................. 49
GridLayout ................................................................................................................................ 51
CONTENEDORES DE ALTO NIVEL ........................................................................................ 54
JDialog ....................................................................................................................................... 55
CONTENEDORES DE NIVEL INTERMEDIO .......................................................................... 56
JScrollPane ................................................................................................................................ 56
JPanel ......................................................................................................................................... 59
12. Programacin Grfica Con Swing
JtabbedPane ............................................................................................................................... 61
JSplitPane .................................................................................................................................. 63
JToolBar .................................................................................................................................... 65
MENUS ......................................................................................................................................... 67
JMenuBar .................................................................................................................................. 67
JMenu ........................................................................................................................................ 67
JMenuItem ................................................................................................................................. 68
OTRAS CLASES BSICAS ........................................................................................................ 74
Evento con Teclado ................................................................................................................... 74
CLASE Color ............................................................................................................................ 78
CLASE Font .............................................................................................................................. 80
CLASE MouseAdapter .............................................................................................................. 81
CLASE ImageIcon .................................................................................................................... 83
CLASE Graphics ....................................................................................................................... 85
CONFIGURANDO EL "Look & Feel" DE UNA APLICACIN ........................................... 92
APPLETS ...................................................................................................................................... 98
Ciclo de vida de un applet ......................................................................................................... 98
El tag Applet en HTML ........................................................................................................... 104
Paso de parmetros a un applet desde HTML ......................................................................... 111
Ejemplos con el mtodo getParameter() .................................................................................. 112

PROGRAMACIN GRFICA CON SWING

El objetivo de este tema es ensear a disear pequeas interfaces grficas empleando
para ello las libreras grficas Swing. Una interfaz es lo que le permite a un usuario
comunicarse con un programa, una interfaz es lo que nosotros vemos al arrancar, por
ejemplo, un navegador de internet: un conjunto de mens, botones, barras.... que nos
permiten activar un cdigo que es el que realmente nos llevar a una pgina web,
salvar la imagen en el disco duro.... Las libreras grficas que usaremos vienen a
sustituir a las antiguas AWT. Las nuevas libreras a parte de tener una mayor cantidad
de opciones sobre los componentes (como distintas apariencias, control sobre el focus,
mayor nmero de campos que modifican su aspecto, mayor facilidad para pintar al
hacer el buffering transparente al usuario....) se diferencian de las anteriores
radicalmente en su implementacin.

Ojo: En AWT cuando aadamos un botn, por ejemplo, a nuestro diseo el compilador
generaba cdigo que le peda al sistema operativo la creacin de un botn en un
determinado sitio con unas determinadas propiedades; en Swing ya no se pide al
sistema operativo nada: se dibuja el botn sobre la ventana en la que lo queramos.
Con esto se eliminaron muchos problemas que existan antes con los cdigos de las
interfaces grficas, que debido a depender del sistema operativo para obtener sus
componentes grficos, era necesario probar los programas en distintos sistemas
operativos, pudiendo tener distintos bugs en cada uno de ellos. Esto evidentemente iba
en contra de la filosofa de Java, supuestamente un lenguaje que no dependa de la
plataforma. Con Swing se mejor bastante este aspecto: lo nico que se pide al sistema
operativo es una ventana, una vez que tenemos la ventana dibujamos botones, listas,
scroll-bars... y todo lo que necesitemos sobre ella. Evidentemente esta aproximacin
gana mucho en lo que a independencia de la plataforma se refiere. Adems el hecho de
que el botn no sea un botn del sistema operativo. sino un botn pintado por Java nos
da un mayor control sobre su apariencia.
Una estrategia para estudiar SWING es dividirlas en:
Componentes.
Contenedores.
Layouts (Administradores de diseo).
Eventos.
Componentes. Son clases o interfaces que permiten crear los objetos grficos que
componen una GUI (Graphics User Interface) tales como; botones, listas desplegables,
cuadros de texto, casillas de verificacin, botones de opcin, campos de texto,
etiquetas, mens, etc.
Contenedores. Son clases o interfaces que permiten crear objetos grficos para
contener a los componentes, tales como; paneles, cuadros de dilogo, marcos,
ventanas, etc.
Layouts. Son clases o interfaces que permiten crear objetos que administren el diseo,
la distribucin y colocacin de los objetos componentes dentro de los objetos
contenedores. Por ejemplo el FlowLayout distribuye los componentes de izquierda a
derecha y de arriba a abajo, el BorderLayout los distribuye en cinco reas geogrficas;
norte, sur, este, oeste y centro, etc.
Eventos. Son las clases o interfaces que permiten crear objetos que capturen y
manejen los eventos. Un evento es una accin sobre algn componente, por ejemplo,
clic a un botn, pulsar la tecla de enter en un botn, mover un elemento con las teclas
de navegacin, eventos especiales como los programados por tiempo, etc. Sin los
eventos las GUI seran interfaces grficas sin vida, y por lo tanto no seran muy tiles
que digamos.

CARACTERISTICAS DE SWING

Se creo como una extensin de la AWT aadiendo las siguientes caractersticas:
Componentes Swing.
Soporte de Look& Feel.
API de accesibilidad.
Java 2D API.
Soporte de Drag& Drop.
Habitualmente tambin se usa como trmino genrico para referirse a las JFC
(Java Foundation Classes).
Su diferencia ms importante con la AWT es que los componentes son
lightweight.
Para diferenciar los componentes Swing de los AWT, sus nombres estn
precedidos por una J.
Todas las clases Swing se encuentran en el paquete javax.swing.*
Nunca debemos mezclar componentes Swing con componentes AWT en una
misma aplicacin: Lightweight vs. Heavyweight.
Swing sigue trabajando con los conceptos de la AWT:
Contenedores.
Componentes.
LayoutManagers.
Eventos.

JERARQUA DE COMPONENTES DEL SWING



COMPONENTES
Como habamos mencionado al principio de este captulo, los componentes son clases
o interfaces que permiten crear los objetos grficos que componen una GUI. La tabla
siguiente nos introduce brevemente a la amplia gama de los componentes deL SWING.
Tipo de
Componente
Descripcin
JButton Es un botn usado para recibir el clic del ratn.
JCanvas Un lienzo o panel usado para dibujar.
JCheckbox Cuadro de verificacin. Es un componente que le permite seleccionar un elemento.
JCheckboxMenuItemEs un cuadro de verificacin dentro de un men.
JChoice Es una lista desplegable de elementos estticos.
JComponent
Se trata de una clase abstracta que implementa toda la funcionalidad bsica de
las clases visuales.
JContainer Es el padre de todos los contenedores.
JDialog Es un cuadro de dilogo o una ventana de alto nivel con titulo y bordes.
JFrame
Es un marco o ventana y es la clase base de todas las ventanas GUI con
controles para ventana.
JLabel Etiqueta. Es una cadena de texto como componente.
JList Un componente que contiene un conjunto dinmico de elementos.
JMenu
Es un elemento dentro de la barra de men, el cual contiene un conjunto de
elementos de tipo men.
JMenuItem Un elemento dentro de un men.
JPanel
Una clase contenedora bsica usado frecuentemente para crear diseos (layouts)
complejos.
JScroollbar
Un componente que permite al usuario hacer una seleccin dentro de un rango de
valores.
JScroolPane
Una clase contenedora que implementa un deslizador horizontal y vertical para un
nico componente hijo.
JTextArea Un componente que permite al usuario introducir texto en un bloque o rectngulo.

Tabla. Componentes bsicos de SWING.

EVENTOS

El sistema de gestin de eventos de Java 1.2 es el mismo que Java 1.1 y por lo tanto el
mismo que para las libreras AWT. Aunque los desarrolladores de Java considerasen
que para mejorar el lenguaje se necesitaba dejar a un lado las libreras AWT e introducir
las Swing no sintieron lo mismo del sistema de gestin de eventos, consideraron que
era lo suficientemente bueno. Realmente este sistema de gestin de eventos es
bastante elegante y sencillo, sobre todo si se compara con el sistema de gestin de
eventos de Java 1.0, mucho ms engorroso de usar y menos elegante.

12.
M.C. Emmanuel Zenn Rivera Blas
Qu es un evento?

Un evento es una accin sobre algn componente
estn constantemente atendiendo a los eventos generados por los usuarios. Estos
eventos pueden ser pulsar una tecla, mover el ratn, hacer clic con el
ratn sobre un botn o men (Java distingue entre simplemente pulsar el ratn en un
sitio cualquiera o hacerlo, por ejemplo, en un botn). El sistema operativo notifica a las
aplicaciones que estn ocurriendo estos eventos, y ellas decide
no de algn modo a este evento.

El modelo de delegacin de eventos

El modelo de Java se basa en la delegacin de eventos
determinado componente, por ejemplo un
denomina fuente del evento. A continuacin el evento se transmite a
de eventos (event listener) que este asignado al componente en el que se produjo el
evento. El objeto que escucha los eventos es el que se encargar de responder a ellos
adecuadamente. Esta separacin de cdigo entre generacin del evento y actuacin
respecto a l facilita la labor del programador y da una mayor claridad a los cdigos.

M.C. Emmanuel Zenn Rivera Blas
Qu es un evento?
es una accin sobre algn componente. Todos los sistemas operativos
eventos pueden ser pulsar una tecla, mover el ratn, hacer clic con el
aplicaciones que estn ocurriendo estos eventos, y ellas deciden si han de responder o
no de algn modo a este evento.
El modelo de delegacin de eventos
El modelo de Java se basa en la delegacin de eventos: el evento se produce en un
determinado componente, por ejemplo un botn. Dnde se produce el evento se
nomina fuente del evento. A continuacin el evento se transmite a
ecuadamente. Esta separacin de cdigo entre generacin del evento y actuacin
Programacin Grfica Con Swing
Pgina 10
Todos los sistemas operativos
eventos pueden ser pulsar una tecla, mover el ratn, hacer clic con el ratn, pulsar el
n si han de responder o
: el evento se produce en un
. Dnde se produce el evento se
nomina fuente del evento. A continuacin el evento se transmite a un manejador
ecuadamente. Esta separacin de cdigo entre generacin del evento y actuacin


Figura. Gestin de eventos en Java.

Explicacin de la Figura: A la fuente del evento, en este caso un botn, le indicamos
quin ser su manejador de eventos (es el mtodo que atender el evento), manejador
que ha de extender la clase Adapter correspondiente o implementar la interfaz Listener
(interfaz ActionLitener en este caso). Cuando el usuario genere el evento deseado (en
este caso pulse el botn), el objeto fuente empaqueta informacin a cerca del evento
generando un objeto de tipo Event (ActionEvent en este caso) e invoca el mtodo
correspondiente del manejador (actionPerformed(actionEvent)) pasndole como
informacin el objeto de tipo Event generado. Es responsabilidad del manejador, y no
de la fuente, responder al evento, por ello se dice que la fuente delega la gestin del
evento en el manejador.

Lo que la fuente de eventos le pasa al objeto encargado de escuchar los eventos es,
como no, otro objeto. Es un objeto tipo Event. En este objeto va toda la informacin
necesaria para la correcta gestin del evento por parte del objeto que escucha los
eventos. El objeto que escucha los eventos ha de implementar para ello una
interface. El nombre de esta interface es siempre el nombre del evento ms
Listener. Para que un objeto escuche eventos de ratn ha de implementar la
interface MouseListener, para que escuche eventos de teclado KeyListener.....

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

public class JButtonTest1 {
public static void main(String[] args) {
JFrame f=new JFrame();
f.setTitle("JButtonTest");
f.setSize(300,150); //(Largo,Alto)dimensin de la ventana del frame
//Coloca los componentes de forma consecutiva
f.getContentPane().setLayout(new FlowLayout());

/*Manejador de Eventos para todos los botones Utiliza Clase Annima*/
ActionListener actionListener = new ActionListener() { //Agregamos un oyente al botn
public void actionPerformed(ActionEvent ev) {//Tratamiento del evento
System.out.println("Etiqueta del botn: " + ev.getActionCommand());
}
};

JButton b1= new JButton("Aceptar");//Crea un Botn con la Etiqueta Aceptar
b1.addActionListener(actionListener);//se dispara el evento
f.getContentPane().add(b1);//Agrega el botn al Contenedor

JButton b2= new JButton("Cancelar");//Crea un Botn con la Etiqueta Cancelar

JButton b3= new JButton("Reintentar");//Crea un Botn con la Etiqueta Reintentar

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// jdk1.3+=> Cerrar una ventana
f.setVisible(true);
}//end main()
}///:~


public class JButtonTest2 {
f.setTitle("JButtonTest");
f.getContentPane().setLayout(new FlowLayout()); //Coloca los componentes de forma consecutiva

/*Manejador de Eventos en cada uno de los botones
*Utiliza Clase Annima*/
JButton b1= new JButton("Aceptar");//Crea un Botn con la Etiqueta Aceptar
b1.addActionListener(new ActionListener() {//Agregamos un oyente al botn
}
});

JButton b2= new JButton("Cancelar");//Crea un Botn con la Etiqueta Cancelar
}
});

f.setVisible(true);
}
}///:~

Tipos de Eventos

Fsicos:
ComponentEvent

Esconder, mover, redimensionar, mostrar un componente.

ContainerEvent

Aadir o eliminar un componente de un container.

FocusEvent

Obtener o perder el focus.

KeyEvent

Pulsar, soltar una tecla.

MouseEvent

Pulsar o soltar un botn del ratn; entrar o salir de un
componente; mover o arrastrar el ratn (tener en cuenta que
este evento tiene dos Listener). MouseListener y
MouseMotionListener.

MouseMotionEvent

Arrastrar o mover el mouse.

WindowEvent

Maximizar, minimizar, abrir, cerrar, activar o desactivar una
ventana.

Semnticos:
ActionEvent Clic en el botn.

AdjustmentEvent

Cambiar el valor de un componente.

ItemEvent

Seleccionar o deseleccionar un Item.

TextEvent

Un texto ha cambiado.

Nuevos tipos de eventos
AncestorEvent Un padre se ha aadido, movido o eliminado.
CaretEvent El cursor en un texto ha cambiado.
ChangeEvent El estado ha cambiado.
DocumentEvent Los atributos de un Document han cambiado,
se ha insertado o se ha eliminado contenido.
HyperlinkEvent Se ha activado, entrado o salido de un hyperlink.
InternalFrameEvent Se ha activado, cerrado, desactivado, minimizado, maximizado
o abierto un internal frame.
ListDataEvent Ha cambiado el contenido.


ListSelectionEvent Ha cambiado la seleccin en una lista.
MenuDragMouseEvent El ratn se ha arrastrado, entrado, salido, soltado en un
men.
MenuEvent Se ha seleccionado o deseleccionado un men.
MenuKeyEvent Se ha pulsado, soltado o tecleado sobre un men.
PopupMenuEvent

Se ha mostrado, ocultado o seleccionado un men
emergente.
TableColumnModelEvent Se ha aadido, eliminado, movido, redimensionada o
seleccionada una columna.
TableModelEvent El modelo de la tabla ha cambiado.

TreeExpansionEvent Se ha abierto o cerrado el rbol.
TreeModelEvent Se ha cambiado, aadido o eliminado un elemento del rbol.
TreeSelectionEvent Ha cambiado la seleccin en el rbol.
UndoableEditEvent Se ha realizado una operacin que no se puede deshacer.

Origen de eventos

Componente
Swing
Evento
Listener interface
Mtodo que escucha el evento
ActionEvent
ActionListener
addActionListen
er()
AdjustmenEvent
AdjustmenListener
addAdjustmenListe
ner()
ComponentEvent
ComponentListener
addComponentListe
ner()
ContainerEvent
ContainerListener
addContainerListen
er()
FocusEvent
FocusListener
addFocusListen
er()

ItemEvent
ItemListener
addItemListen
er()
KeyEvent
KeyListener
addKeyListen
er()
MouseEvent
MouseListener
addMouseListen
er()

MouseMotionEvent
MouseMotionListener
addMouseMotionListe
ner()
TextEvent
TextListener
addTextListen
er()
WindowEvent
WindowListener
addWindowListen
er()
AbstractButton
x x
JApplet
x x x x x x
JButton
x x x x x x
JCanvas
x x x x x
JCheckBox
x x x x x x
JCheckBoxMenuI
tem
x x
JChoice
x x x x x x
JComboBox
x x x x x x
JComponent
x x x x x
JContainer
x x x x x x
DefaultButtonMod
el
x x
JDialog
x x x x x x x x
JFileChooser
x
JFileDialog
x x x x x x x x
JFrame
x x x x x x x x
JLabel
x x x x x
JList
x x x x x x x
JMenu
x
JMenuItem
x
JPanel
x x x x x x
JPopupMenu
x
JScrollBar
x x x x x x
JScrollPane
x x x x x x
JTextArea
x x x x x x
JTextField
x x x x x x x
Window
x x x x x x x x

Tabla. Listeners de los componentes bsicos de Swing.

Componente
Swing
AncestorEvent
AncestorListener
addAncestorListener()
CaretEvent
CaretListener
addCaretListener()
CellEditorEvent
CellEditorListener
addCellEditorListener()
ChangeEvent
ChangeListener
addChangeListener()
ColumnModelEvent
ColumnModelListener
addColumnModelListener()
DocumentEvent
DocumentListener
addDocumentListener()

AbstractButton x x
AbstractDocument
DefaultBoundedRangeModel x
DefaultButtonModel x
DefaultCaret x
DefaultCellEditor x
DefaultColorSelectionModel x
DefaultSingleSelectionModel x
DefaulStyledDocument x
DefaultTableColumnModel x
DefaultTreeCellEditor x
JComponent x
MenuSelectionManager x
JProgressBar x
JTabbedPane x
JTextComponent x
JSlider x
JViewport x
StyleContext x
StyleContext.NamedStyle x

Tabla. Listeners de los componentes avanzados de Swing.

Componente
Swing
HyperlinkEvent
HyperlinkListener
addHyperlinkListener()
InternalFrameEvent
InternalFrameListener
addInternalFrameListener()
ListDataEvent
ListDataListener
addListDataListener()

ListSelectionEvent
ListSelectionListener
addListSelectionListener()
MenuDragMouseEvent
MenuDragMouseListener
add
MenuDragMouseListener()
MenuKeyEvent
MenuKeyListener
addMenuKeyListener()

AbstractListModel x
DefaultListSelectionModel x
JEditorPane x
JInternalFrame x
JMenuItem x x
JList x



Componente
Swing
MenuEvent
MenuListener
addMenuListener()
PopupMenuEvent
PopupMenuListener
addPopupMenuListener()
PropertyChangeEvent
PropertyChangeListener
addPropertyChangeListener()
TableModelEvent
TableModelListener
addTableModelListener()
AbstractAction x
AbstractTableModel x
DefaultTreeModel
DefaultTreeSelectionModel x
JComponent x
JMenu x
JPopupMenu x
JTree
SwingPropertyChangeSupport x
TableColumn x
UIDefaults x
UIManager x


Componente
Swing
TreeExpansionEvent
TreeExpansionListener
addTreeExpansionListener()
TreeModelEvent
TreeModelListener
addTreeModelListener()
TreeSelectionEvent
TreeSelectionListener
addTreeSelectionListener()
UndoableEditEvent
UndoableEditListener
add UndoableEditListener()
VetoableChangeEvent
VetoableChangeListener
add VetoableChangeListener()
AbstractDocument x
DefaultTreeModel x
DefaultTreeSelectionModel x
JComponent x
JTree x X
UndoableEditSupport x


Adapters

Cabe preguntarse ahora qu mtodos tiene cada interface, ya que hemos de
implementar todos ellos, incluso aunque no los usemos, sino la clase que se
encargara de escuchar los eventos sera abstracta y no podramos crear ningn objeto
de ella. Parece un poco estpido implementar mtodos que no hagan nada slo porque
la interface de la que heredamos los tenga. As por ejemplo si estamos interesados en
escuchar cerrar la ventana de un JFrame hemos de crear una clase que implemente
WindowListener, pero nosotros slo estaremos interesados en un mtodo de dicha
interfase: windowClosing(WindowEvent ev). Los creadores de Java tambin
pensaron en esto y por ello para cada interface que tiene ms de un mtodo crearon
una clase llamada [nombre_evento]Adapter (WindowAdapter), que lo que hace es
implementar todos los mtodos de la interface sin hacer nada en ellos. Nosotros lo
nico que tendremos que hacer es que nuestra clase que escuche eventos extienda
esta clase y sobrescriba los mtodos que nos interesen.


public class WindowListenerTest{
f.setTitle("Probando cerrar Window con Listener");

/*Como es una Interface se deben de implementar
*todos sus mtodos de WindowListener*/
f.addWindowListener(new WindowListener()
{
public void windowClosing(WindowEvent ev) { System.exit(0); }
public void windowActivated(WindowEvent ev) {}
public void windowClosed(WindowEvent ev) {}
public void windowDeactivated(WindowEvent ev) {}
public void windowDeiconified(WindowEvent ev) {}
public void windowIconified(WindowEvent ev) {}
public void windowOpened(WindowEvent ev) {}
});
//f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//jdk1.3+=>Cerrar una ventana
f.setVisible(true);
}
}///:~

public class WindowAdapterTest {
f.setTitle("Probando Cerrar Window con Adpaters");

/* Cdigo obsoleto para cerrar ventanas en Java
*Como es una clase Adapter solo se implementa el mtodo
*que se requiere para cerra la ventana*/
f.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
});

//f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// jdk1.3+=> Cerrar una ventana
f.setVisible(true);
}
}///:~

A continuacin en la siguiente tabla damos un listado de las principales interfaces junto
a sus respectivas clases Adapter y los mtodos que poseen:

Evento
Listener interface
Y Adapter
Mtodos con su evento (ev es una instancia del objeto event,
puede ser cualquier otro nombre).
ActionEvent
ActionListener
actionPerformed(ActionEvent ev)
AdjustmentEvent
AdjustmentListener
adjustmentValueChanged(AdjustmentEvent ev)
ComponentEvent
ComponentListener
ComponentAdapter
componentHidden(ComponentEvent ev)
componentShown(ComponentEvent ev)
componentMoved(ComponentEvent ev)
componentResized(ComponentEvent ev)
ContainerEvent
ContainerList
ContainerAdapter
componentAdded(ContainerEvent ev)
componentRemoved(ContainerEvent ev)

FocusEvent
FocusListener
FocusAdapter
focusGained(FocusEvent ev)
focusLost(FocusEvent ev)
ItemEvent
ItemListener
itemStateChanged(ItemEvent ev)
KeyEvent
KeyListener
KeyAdapter
keyPressed(KeyEvent ev)
keyReleased(KeyEvent ev)
keyTyped(KeyEvent ev)
MouseEvent
MouseListener
MouseAdapter
mouseClicked(MouseEvent ev)
mouseEntered(MouseEvent ev)
mouseExited(MouseEvent ev)
mousePressed(MouseEvent ev)
mouseReleased(MouseEvent ev)
MouseEvent
MouseMotionListener
MouseMotionAdapter
mouseDragged(MouseEvent ev)
mouseMoved(MouseEvent ev)
TextEvent
TextListener
textValueChanged(TextEvent ev)
WindowEvent
WindowListener
WindowAdapter
windowActivated(WindowEvent ev)
windowClosed(WindowEvent ev)
windowClosing(WindowEvent ev)
windowDeactivated(WindowEvent ev)
windowDeiconified(WindowEvent ev)
windowIconified(WindowEvent ev)
windowOpened(WindowEvent ev)

Tabla. Interfaces y Adapters con sus respectivos mtodos.

Evento
Listener interface
Mtodos con su evento (ev es una instancia del objeto
event, puede ser cualquier otro nombre).
AncestorEvent
AncestorListener
ancestorAdded(AncestorEvent ev)
ancestorMoved(AncestorEvent ev)
ancestorRemoved(AncestorEvent ev)
CaretEvent
CaretListener
caretUpdate(CareEvent ev)

CellEditorEvent
CellEditorListener
editingCanceled(CellEditorEvent ev)
editingStopped(CellEditorEvent ev)
ChangeEvent
ChangeListener
stateChanged(ChangedEvent ev)

DocumentEvent
DocumentListener
changedUpdate(DocumentEvent ev)
insertUpdate(DocumentEvent ev)
removeUpdate(DocumentEvent ev)
HyperlinkEvent
HyperlinkListener
hyperlinkUpdate(HyperlinkEvent ev)

InternalFrameEvent
InternalFrameListener

internalFrameActivated(InternalFrameEvent ev)
internalFrameClosed(InternalFrameEvent ev)
internalFrameClosing(InternalFrameEvent ev)
internalFrameDeactivated(InternalFrameEvent ev)
internalFrameDeiconified(InternalFrameEvent ev)
internalFrameIconified(InternalFrameEvent ev)
internalFrameOpened(InternalFrameEvent ev)
ListDataEvent
ListDataListener

contentsChanged(ListDataEvent ev)
intervalAdded(ListDataEvent ev)
intervalRemoved(ListDataEvent ev)
ListSelectionEvent
ListSelectionListener
valueChanged(ListSelectionEvent ev)
MenuDragMouseEvent
MenuDragMouseListener

menuDragMouseDragged(MenuDragMouseEvent ev)
menuDragMouseEntered(MenuDragMouseEvent ev)
menuDragMouseExited(MenuDragMouseEvent ev)
menuDragMouseReleased(MenuDragMouseEvent ev)
MenuKeyEvent
MenuKeyListener

menuKeyPressed(MenuKeyEvent ev)
menuKeyReleased(MenuKeyEvent ev)
menuKeyTyped(MenuKeyEvent ev)
MenuEvent
MenuListener

menuCanceled(MenuEvent ev)
menuDeselected(MenuEvent ev)
menuSelected(MenuEvent ev)

Tabla. Interfaces y Adapters nuevos con sus respectivos mtodos.

Evento
Listener interface
Mtodos con su evento (ev es una instancia del objeto
event, puede ser cualquier otro nombre).
MouseInputEvent
MouseInputListener

mouseClicked(MouseInputEvent ev)
mouseDragged(MouseInputEvent ev)
mouseEntered(MouseInputEvent ev)
mouseExited(MouseInputEvent ev)
mouseMoved(MouseInputEvent ev)
mousePressed(MouseInputEvent ev)
mouseReleased(MouseInputEvent ev)
PopupMenuEvent
PopupMenuListener

popupmenuCanceled(PopupMenuEvent ev)
popupMenuWillBecomeInvisible(PopupMenuEvent ev)
popupMenuWillBecomeVisible(PopupMenuEvent ev)
TableColumnModelEvent
TableColumnModelListener

columnAdded(TableColumnModelEvent ev)
columnMarginChanged(TableColumnModelEvent ev)
columnMoved(TableColumnModelEvent ev)
columnRemoved(TableColumnModelEvent ev)
columnSelectionChanged(TableColumnModelEvent ev)
TableModelEvent
TableModelListener
tableChanged(TableModelEvent ev)

TreeExpansionEvent
TreeExpansionListener
treeCollapsed(TreeExpansionEvent ev)
treeExpanded(TreeExpansionEvent ev)
TreeModelEvent
TreeModelListener

treeNodesChanged(TreeModelEvent ev)
treeNodesInserted(TreeModelEvent ev)
treeNodesRemoved(TreeModelEvent ev)
treeStructureChanged(TreeModelEvent ev)
TreeSelectionEvent
TreeSelectionListener
valueChanged(TreeSelectionEvent ev)

UndoableEditEvent
UndoableEditListener
undoableEditHappened(UndoableEditEvent ev)

Tabla. Interfaces y Adapters nuevos con sus respectivos mtodos.
COMPONENTES ATMICOS DEL SWING

En esta seccin veremos ejemplos que hacen uso de los componentes, del paquete
java.x.swing los cuales puede escoger para crear su GUI.

JButton

Ya nos es familiar que un objeto de la clase JButton sea un componente. El manejo de
botones ya se abordo en la seccin de El modelo de delegacin de eventos, por tal
motivo se dar por visto este tema.

JCheckBox
El componente JCheckBox nos provee de un simple dispositivo de
encendido/apagado con una etiqueta de texto a un lado. Veamos el siguiente ejemplo:
Si se selecciona el JCheckBox correspondiente desplegar el sabor del helado
correspondiente, si se quita la marca de verificacin o la palomita escribir que se
deselecciono ese sabor correspondiente.

import javax.swing.JCheckBox;
import java.awt.Color;
import java.awt.event.ItemListener;
import java.awt.event.ItemEvent;

public class JCheckBoxTest{
public static void main(String args[]){
JFrame f = new JFrame();
f.setTitle("Ricos Helados");// titulo del JFrame
f.setSize(370,145);

// se crean los componentes JCheckBox
JCheckBox fresa = new JCheckBox("FRESA");//Se inicializa con FRESA
JCheckBox mango = new JCheckBox();
JCheckBox limon = new JCheckBox();

fresa.setBackground(Color.pink); // color del fondo, hereda de la clase JComponent
fresa.addItemListener(new ItemListener() // se agrega un oyente
{
public void itemStateChanged(ItemEvent ev){
//se implementa un mtodo por claridad del cdigo
fresita(ev);// se delega el evento
}
});


mango.setText("MANGO");
mango.setBackground(Color.yellow);
mango.addItemListener(new ItemListener()
{
//se hace la implementacin aqui mismo
if(ev.getStateChange()== ItemEvent.SELECTED)
System.out.println("Rico helado de mango");
else
System.out.println("Deselecciono mango");
}
});

limon.setText("LIMON");
limon.setBackground(Color.green);
limon.addItemListener(new ItemListener()
{
if(ev.getStateChange() == ItemEvent.SELECTED)
System.out.println("Rico helado de limn");
else
System.out.println("Deselecciono Limn");
}
});

f.getContentPane().add(fresa);//Agrega el componente al Contenedor
f.getContentPane().add(mango);//Agrega el componente al Contenedor
f.getContentPane().add(limon);//Agrega el componente al Contenedor

f.setVisible(true);
//el mtodo setVisible se hereda de la superclase Component
}//end main()

private static void fresita(ItemEvent ev){
if(ev.getStateChange() == ItemEvent.SELECTED)
System.out.println("Rico helado de Fresa");
else
System.out.println("Deselecciono Fresa");
//static int SELECTED =>This state-change value indicates that an item was selected.
//int getStateChange()=>Returns the type of state change (selected or deselected).
}
}///:~

La seleccin o deseleccin de un JCheckBox es enviada a la interface
ItemListener. El ItemEvent es enviado conteniendo el mtodo getStatedChange(), el
cual regresa ItemEvent.DESELECTED o un ItemEvent.SELECTED, segn sea el
caso.

JRadioButton

Si se quieren botones de seleccin nica, los conocidos como botones radio, que tienen
la particularidad de que solamente puede haber uno seleccionado. Cuando aadimos
estos componentes (JRadioButtons) a nuestro diseo se aaden por grupos
(ButtonGroup), aadiendo botones a ese grupo uno a uno; la seleccin de uno distinto
dentro de un grupo provoca la inmediata deseleccin del que antes estaba
seleccionado. Se emplean para darle a elegir al usuario entre un grupo de opciones
mutuamente excluyentes. Swing permite que cualquier AbstractButton pueda ser
aadido a un ButtonGroup.

En este ejemplo se utiliza un solo manejador de eventos para cada pulsacin del
JRadioButton y se crea una clase interna.

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

public class JRadioButtonTest{
/*static y global por k se utilizan en la clase ManejadorBotonOpcion
Se crea un cuadro de texto inicializado con 30 columnas*/
private static JTextField campo = new JTextField( "cambia el estilo del tipo de letra", 30);

f.setTitle("JRadioButton Tipos de Letras");// titulo del JFrame
f.setSize(350,100);

JRadioButton botonSimple = new JRadioButton("Simple",true);
JRadioButton botonNegrita = new JRadioButton("Negrita",false);
JRadioButton botonCursiva = new JRadioButton("Cursiva",false);

// crear relacin lgica entre objetos JRadioButton para que sean exclusivos
ButtonGroup grupoBotonesOpcion = new ButtonGroup();
grupoBotonesOpcion.add(botonSimple);
grupoBotonesOpcion.add(botonNegrita);
grupoBotonesOpcion.add(botonCursiva);

// crear objetos de tipo de letra
Font tipoLetraSimple = new Font("Serif", Font.PLAIN, 14);
Font tipoLetraNegrita = new Font("Serif", Font.BOLD, 14);
Font tipoLetraCursiva = new Font("Serif", Font.ITALIC, 14);
//Font tipoLetraNegritaCursiva = new Font("Serif", Font.BOLD + Font.ITALIC, 14);

// registrar eventos para objetos JRadioButton
botonSimple.addItemListener(new ManejadorBotonOpcion(tipoLetraSimple));
botonNegrita.addItemListener(new ManejadorBotonOpcion(tipoLetraNegrita));
botonCursiva.addItemListener(new ManejadorBotonOpcion(tipoLetraCursiva));

f.getContentPane().add(campo);//Agrega el componente al Contenedor
f.getContentPane().add(botonSimple);//Agrega el componente al Contenedor
f.getContentPane().add(botonNegrita);//Agrega el componente al Contenedor
f.getContentPane().add(botonCursiva);//Agrega el componente al Contenedor

f.setVisible(true);
}//end main()

//clase static pork se utilizan componentes que estan en el main()y es static
private static class ManejadorBotonOpcion implements ItemListener {
private Font tipoDeLetra;

public ManejadorBotonOpcion(Font f)
{
tipoDeLetra = f;
}

// manejar eventos de botn de opcin
public void itemStateChanged(ItemEvent ev)
{
campo.setFont(tipoDeLetra);
}
}//~ fin de la clase interna privada ManejadorBotonOpcion
}///:~


En este otro ejemplo se utilizan diferentes manejadores de eventos, es decir, uno para
cada pulsacin de JRadioButton. Estos ejemplos se programaron de diferente manera
para aprender a crear o manipular diversos cdigos con interfaces graficas del swing.

import java.awt.*;

public class JRadioButtonTest2{
f.setTitle("JRadioButton Tipos de Letras");// titulo del JFrame
f.setSize(350,120);

//Se crea un cuadro de texto inicializado con 30 columnas es final ya k utiliza clases internas
final JTextField campo = new JTextField( "cambia el estilo del tipo de letra", 30);

JRadioButton botonSimple = new JRadioButton("Simple",true);
JRadioButton botonNegrita = new JRadioButton("Negrita",false);
JRadioButton botonCursiva = new JRadioButton("Cursiva",false);

// crear relacin lgica entre objetos JRadioButton para que sean exclusivos
ButtonGroup grupoBotonesOpcion = new ButtonGroup();
grupoBotonesOpcion.add(botonSimple);
grupoBotonesOpcion.add(botonNegrita);
grupoBotonesOpcion.add(botonCursiva);

botonSimple.addItemListener(new ItemListener(){
{
Font tipoLetraSimple = new Font("Serif", Font.PLAIN, 14);
campo.setFont(tipoLetraSimple);
}
});

botonNegrita.addItemListener(new ItemListener(){
{
Font tipoLetraNegrita = new Font("Serif", Font.BOLD, 14);
campo.setFont(tipoLetraNegrita);
}
});

botonCursiva.addItemListener(new ItemListener(){
public void itemStateChanged(ItemEvent ev) {
Font tipoLetraCursiva = new Font("Serif", Font.ITALIC, 14);
campo.setFont(tipoLetraCursiva);
}
});

f.getContentPane().add(campo);//Agrega el componente al Contenedor
f.getContentPane().add(botonSimple);//Agrega el componente al Contenedor
f.getContentPane().add(botonNegrita);//Agrega el componente al Contenedor
f.getContentPane().add(botonCursiva);//Agrega el componente al Contenedor

f.setVisible(true);
}//end main()
}///:~

JList

Se trata de un componente con una funcin similar a los dos anteriores (JCheckBox y
JRadioButton), slo que aqu las posibles selecciones se encuentran en una lista, que
normalmente lleva un scroll incorporado, y se seleccionan haciendo clic directamente
sobre ellas. Se emplea cuando el nmero de opciones entre las que ha de escoger el
usuario es demasiado grande para presentrsela en forma de radiobuttons o
checkboxes. Posee mtodos para permitir simple o mltiple seleccin, seleccionar o
deseleccionar un componente, averiguar que componente est seleccionado...

import javax.swing.JList;

public class JListTest1 {
f.setTitle("JListTest");
f.setSize(200,180);
String[] labels={"Primero","Segundo","Tercero",
"Cuarto","Quinto","Sexto",
"Septimo","Octavo","Noveno"};
JList list=new JList(labels);
f.getContentPane().add(list);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}// end main()
}///:~

import javax.swing.JList;
import javax.swing.JScrollPane;
//nuevos eventos de swing
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

public class JListTest2 {
f.setTitle("JListTest");
f.setSize(200,230);

String labels[] = { "OPCION_1", "OPCION_2", "OPCION_3", "OPCION_4",
"OPCION_5", "OPCION_6", "OPCION_7", "OPCION_8",
"OPCION_9", "OPCION_10" };

JList lista = new JList(labels);
f.getContentPane().add(lista);

JScrollPane scrollPane = new JScrollPane(lista);
f.getContentPane().add(scrollPane);

ListSelectionListener listSelectionListener = new ListSelectionListener() {
public void valueChanged(ListSelectionEvent ev) {
JList list = (JList) ev.getSource();
int indice = list.getSelectedIndex();
Object valor = list.getSelectedValue();
System.out.println("Indice=> " + indice + "valor=> " + valor);
}
};
lista.addListSelectionListener(listSelectionListener);

f.setVisible(true);
}// end main()
}///:~

JComboBox

Su filosofa es idntica a la de JList, pero en esta ocasin las opciones no se ven en un
principio. El usuario ha de hacer un clic sobre una pestaa que desplegar una lista de
opciones sobre las cuales escoge el usuario una mediante un clic.

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JComboBox;

public class JComboBoxTest {
public static void main(final String args[]) {
final String labels[]= {"OPCION_A", "OPCION_B", "OPCION_C", "OPCION_D", "OPCION_E"};
JFrame f = new JFrame("JComboBox");
f.setSize(350,100);
f.getContentPane().setLayout(new FlowLayout()); //Coloca los componentes de forma consecutiva

JComboBox comboBox = new JComboBox(labels);
comboBox.setSelectedIndex(0);
f.getContentPane().add(comboBox);//Agrega el el combo al Contenedor

/*Forma 1*/
/*comboBox.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ev){
JComboBox cb = (JComboBox)ev.getSource();

String opcionSelec = (String)cb.getSelectedItem();
System.out.println("Selected: " + opcionSelec);
}
});
*/

/*Forma 2*/
ActionListener actionListener = new ActionListener() {
public void actionPerformed(ActionEvent ev){
JComboBox cb = (JComboBox)ev.getSource();

String opcionSelec = (String)cb.getSelectedItem();
System.out.println("Selected: " + opcionSelec);
}
};
comboBox.addActionListener(actionListener);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//Cierra la ventana
f.setVisible(true);
}// end main()
}///:~

JLabel

No es ms que una etiqueta de texto que podemos colocar al lado de cualquier
componente para darle una indicacin al usuario de cual es la funcin de dicho
componente.

import javax.swing.JLabel;

public class JLabelTest {
f.setTitle("JLabelTest");
f.setSize(200,100);

JLabel l1=new JLabel("Una etiqueta");
JLabel l2=new JLabel();
l2.setText("Otra etiqueta");

f.getContentPane().add(l1);
f.getContentPane().add(l2);
f.setVisible(true);
}// end main()
}///:~

JTextField y JPasswordField

JTextField: Est pensado para obtener texto del usuario, este teclear en l y cuando
pulse intro podremos disponer del texto que tecle. nicamente se puede recoger una
lnea de texto. Tiene mtodos para recoger el texto del usuario, poner un texto en l,
recoger solo el texto seleccionado, seleccionar una parte del texto, insertar texto, cortar
texto, pegar texto, etc.

JPasswordField: No es ms que un JTextField en el cual al escribir no se ve lo que se
escribe, sino un carcter (*, por ejemplo). Se emplea para pedirle passwords al usuario
y evitar que puedan ser ledas por alguien.

import java.awt.*;

public class JTextFieldTest extends JFrame {
private JTextField campoTexto1, campoTexto2, campoTexto3;
private JPasswordField campoContrasenia;

public JTextFieldTest()
{
super("JTextField y JPasswordField" );

Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );
//f.getContentPane().setLayout(new FlowLayout());

JLabel etiqueta= new JLabel("" +
"Introducir texto y dar enter en cada componente");
contenedor.add(etiqueta);

// crear campo de texto con tamao predeterminado
campoTexto1 = new JTextField(10);
contenedor.add(campoTexto1);

// crear campo de texto con texto predeterminado
campoTexto2 = new JTextField("Escriba el texto aqu");
contenedor.add(campoTexto2);

// crear campo de texto con texto predeterminado,
// 20 elementos visibles y sin manejador de eventos
campoTexto3 = new JTextField( "Campo de texto no editable", 20);
campoTexto3.setEditable(false);
contenedor.add( campoTexto3 );

// crear campo de contrasea con texto predeterminado
campoContrasenia = new JPasswordField("Texto oculto");
contenedor.add( campoContrasenia );

// registrar manejadores de eventos
campoTexto1.addActionListener(new ManejadorCampoTexto());
campoContrasenia.addActionListener(new ManejadorCampoTexto());

setSize(325,150);
setVisible(true);
setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
} // fin del constructor de JTextFieldTest()

// clase interna privada para el manejo de eventos
private class ManejadorCampoTexto implements ActionListener
{ // procesar eventos de campo de texto
public void actionPerformed(ActionEvent ev)
{
String cadena = "";

// el usuario oprimi Intro en objeto JTextField campoTexto1
if (ev.getSource() == campoTexto1)
cadena = "campoTexto1: " + ev.getActionCommand();
//getActionCommand()=> Returns the command string associated with this action

else if (ev.getSource() == campoTexto2)

else if (ev.getSource() == campoTexto3)

// el usuario oprimi Intro en objeto JTextField campoContrasenia
else if (ev.getSource() == campoContrasenia) {
cadena = "campoContrasenia: " + ev.getActionCommand();
// new String(campoContrasenia.getPassword());
}

JOptionPane.showMessageDialog(
null, cadena,"Resultados",JOptionPane.CANCEL_OPTION);
} // fin del mtodo actionPerformed()
} // fin de la clase interna privada ManejadorCampoTexto

public static void main( String args[] )
{
JTextFieldTest aplicacion = new JTextFieldTest();
}
}///:~

JTextArea

Todo lo dicho para JTextField es vlido aqu tambin; la diferencia entre ambos es que
JTextArea permite al usuario introducir ms de una lnea de texto.

En este ejemplo primero se selecciona el texto y despus se pulsa el botn Copiar para
pegar el texto en el cuadro vaco.

import java.awt.*;

public class JTextAreaTest extends JFrame
{
private JTextArea areaTexto1, areaTexto2;
private JButton botonCopiar;

public JTextAreaTest()
{
super("JTextArea");
setSize(450,150);
getContentPane().setLayout(new FlowLayout());

String cadena = "sta es una cadena de\ndemostracin para\n" +
"ilustrar cmo copiar texto\nde un rea de texto a \n" +
"otra, utilizando un\nevento externo";

// establecer areaTexto1
areaTexto1 = new JTextArea(cadena,5,10);
JScrollPane jsp1= new JScrollPane(areaTexto1);
getContentPane().add(jsp1);

// establecer botonCopiar
botonCopiar = new JButton( "Copiar >>>" );
getContentPane().add(botonCopiar);
botonCopiar.addActionListener(new ActionListener()
{ // clase interna annima
// establecer en areaTexto2 el texto seleccionado de areaTexto1
public void actionPerformed(ActionEvent ev)
{
areaTexto2.append(areaTexto1.getSelectedText());
}
});

// establecer areaTexto2
areaTexto2 = new JTextArea(5,10);
areaTexto2.setEditable(false);
JScrollPane jsp2= new JScrollPane(areaTexto2);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// jdk1.3+=> Cerrar una ventana
setVisible(true);
}// fin del constructor

{
JTextAreaTest aplicacion = new JTextAreaTest();
}
}///:~

CUADROS DE DIALOGO ESTNDAR

JOptionPane

Muchas clases Swing soportan dilogos -- ventanas que son ms limitadas que los
JFrame. Para crear un dilogo, simple y estndar se utiliza JOptionPane. Para crear
dilogos personalizados, se utiliza directamente la clase JDialog. JOptionPane
proporciona soporte para mostrar dilogos standards, proporcionando iconos,
especificando el ttulo y el texto del dilogo y personalizando el texto del botn.

Para la mayora de los dilogos modales sencillos, se crea y se muestra el dilogo
utilizando uno de los mtodos showXxxDialog de JOptionsPane.

showMessageDialog
Muestra un dilogo modal con un botn, etiquetado "OK". Se puede especificar
fcilmente el mensaje, el icono y el ttulo que mostrar el dilogo.

showConfirmDialog
Muestra un dilogo modal con dos botones, etiquetados "Yes" y "No". Estas etiquetas
no son siempre terriblemente descriptivas con las acciones especficas del programa
que causan.

showInputDialog
Muestra un dilogo modal que obtiene una cadena del usuario. Un dilogo de entrada
muestra un campo de texto para que el usuario teclee en l, o un JComboBox no
editable, desde el que el usuario puede elegir una de entre varias cadenas.

showOptionDialog
Muestra un dilogo modal con los botones, los iconos, el mensaje y el ttulo
especificado, etc. Con este mtodo, podemos cambiar el texto que aparece en los
botones de los dilogos estndar. Tambin podemos realizar cualquier tipo de
personalizacin.

El soporte de iconos de JOptionPane permite especificar qu icono mostrar el
dilogo. Podemos utilizar un icono personalizado, no utilizar ninguno, o utilizar uno de
los cuatro iconos estndard de JOptionPane (question, information, warning, y error).
Cada aspecto y comportamiento tiene sus propias versiones de los cuatro iconos
estndard.

Por defecto, un dilogo creado con showMessageDialog muestra el icono de
informacin, un dilogo creado con showConfirmDialog o showInputDialog muestra
un icono question. Para especificar qu un dilogo estndard no tenga icono o tenga
otro icono estndard, se aade un parmetro que especifica el tipo de mensaje. El valor
del tipo de mensaje puede ser una de las siguientes constantes: PLAIN_MESSAGE (sin
icono), QUESTION_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE,
o ERROR_MESSAGE. Si especificamos un objeto Icon distinto de null, el dilogo
muestra ese icono, no importa el tipo de mensaje que sea.

public class JOptionPaneTest{
public static void main(String args[]) throws Exception {
//Men de opciones
int opcion; //La opcin que se guardar

//Este string contiene los labels de todos los botones
String[] menu = {"Opcion1", "Opcion2","Mensaje Simple",
"Otro Men","HTML","PideCadena",
"PideEntero","Salir"};

//Inicia el Menu de botones
do{
opcion= JOptionPane.showOptionDialog(
null, //sin parentesco puede ser Frame f
"Selecciona una opcin", //texto que sale
"Ejemplos con JOptionPane", //titulo de la caja
JOptionPane.YES_NO_CANCEL_OPTION,//tipo de caja
JOptionPane.QUESTION_MESSAGE, //tipo de mensaje
null, //icono de la caja
menu, //lista de botones, este es el arreglo
menu[0]); //boton por default

switch(opcion) {
case 0: //Instrucciones aqui Opcion 1
System.out.println("Seleccion la Opcin 1");
break;

case 1: //Instrucciones aqui Opcion 2
System.out.println("Seleccion la Opcin 2");
break;

case 2: //Mensaje Simple
JOptionPane.showMessageDialog(null,"Hola Mundo");
break;

case 3: //Otro menu dentro de esta opcin
//Men de opciones
int opcion2;

//Este string contiene los labels de todos los botones
String[] menu2 = {"Opcin 1","Opcin 2","Salir"};

//Inicia el Menu de botones
do{
opcion2 = JOptionPane.showOptionDialog(
null,
"Selecciona una opcin",
"JOptionPane.showOptionDialog",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.INFORMATION_MESSAGE,
null,
menu2,
menu2[0]);

switch(opcion2) {
case 0: System.out.println("Seleccion la Opcin 1");
break;
case 1: System.out.println("Seleccion la Opcin 2");
break;
case 2: //Para que se salga del do-while
opcion2 = -1;
break;
}//end switch(opcion2)
}while(opcion2 != (-1));// fin del do-while
break;


case 4: //HTML
/* Puedes usar tags de HTML dentro de la string del
* message dialog */
String htmlTags = "" +
"<HTML><HEAD></HEAD>"+
"<BODY>"+
"<CENTER>Mensaje Centrado<CENTER>" +
//Tambien se pueden hacer Tablas
"<TABLE BORDER=1 BGCOLOR=WHITE>"+
"<TR><TH>uno</TH><TH>Dos</TH><TH>Tres</TH></TR>" +
"<TR><TD>celda1</TD><TD>celda2</TD><TD>celda3</TD></TR>"+
"</TABLE></BODY>" +
"</HTML>";
JOptionPane.showMessageDialog(null, htmlTags);
break;

case 5: //PideCadena
String input = "";
//Se entiende por si solo
try {
input = JOptionPane.showInputDialog("Escribe algo");
}catch (Exception e) {
//en caso de algn error muestra mensaje
JOptionPane.showMessageDialog(null, "Error");
break; //sale de esta opcin
}//end try
JOptionPane.showMessageDialog(null, "Cadena: " + input);
break;

case 6: //PideEntero
int entero = 0; //se inicializa

try { //Hacemos parse para convertir a entero
entero = Integer.parseInt (
JOptionPane.showInputDialog("Escribe un entero"));
} catch (Exception e) {
/* en caso de algun error muestra mensaje por ejemplo
* si se introduce algo diferente de un entero */
JOptionPane.showMessageDialog(null, "Error");
break;
}
JOptionPane.showMessageDialog(null, "Nmero: " + entero);

//Se pueden hacer operaciones como siempre
if(entero < 5) {
JOptionPane.showMessageDialog(
null, "El Numero: " + entero + " es menor a 5");
}
break;

case 7: //Salir del programa
opcion = -1;
break;
}// fin del switch
} while(opcion != (- 1) );// fin del do-while
} //end main()
}///:~
Menu Principal

Opcion1

Opcion2

Mensaje Simple

Otro Men

HTML

Pide Cadena

PideEntero

Salir
Sale del Men principal

JFileChooser

La ventana que permite la seleccin de archivos, suele ser una ventana modal, ya que
los cambios que se produzcan en ella, o la seleccin que se haga, repercutirn en el
funcionamiento de la aplicacin general. Normalmente, la ventana de seleccin de
archivos se utiliza para presentar una lista de archivos y permitir al usuario seleccionar
cul de ellos debe abrir la aplicacin; o, por el contrario, permitir al usuario la
introduccin de un nombre o seleccin del archivo con que se quieren salvar datos. El
objeto JFileChooser no realiza ninguna de estas acciones, es decir, no abre ni salva
nada, sino que se limita a sleccionar el nombre del archivo con el que se desea realizar
la accin; es responsabilidad del programa el llevar a cabo la apertura del archivo o la
grabacin de datos.

import javax.swing.JFileChooser;

public class JFileChooserTest {
f.setTitle("JFileChooserTest");
f.setSize(200,150);

JFileChooser fc=new JFileChooser();
int op=fc.showOpenDialog(f);
if(op==JFileChooser.APPROVE_OPTION)
System.out.println(fc.getSelectedFile());

f.setVisible(true);
}//end main()
}///:~


JColorChooser

Panel de controles que permite al usuario seleccionar un color.

import java.awt.*;

public class JColorChooserTest extends JFrame
{
private JButton cambiarColorBoton;
private Color color = Color.LIGHT_GRAY;
private Container contenedor;

// configurar GUI
public JColorChooserTest()
{
super( "JColorChooserTest" );

contenedor = getContentPane();
contenedor.setLayout(new FlowLayout());

// configurar cambiarColorBoton y registrar su manejador de eventos
cambiarColorBoton = new JButton( "Cambiar color" );
cambiarColorBoton.addActionListener(new ActionListener(){
// mostrar JColorChooser cuando el usuario haga clic en el botn
public void actionPerformed( ActionEvent evento )
{
color = JColorChooser.showDialog(
JColorChooserTest.this, "Seleccione un color", color );

// establecer color predeterminado, si no se devuelve un color
// Si se d clic en el botn Cancelar
if ( color == null )
color = Color.RED;

// cambiar color de fondo del panel de contenido
contenedor.setBackground( color );
}
});
contenedor.add( cambiarColorBoton );

setSize( 400, 130 );
setVisible( true );
} // fin del constructor

{
JColorChooserTest aplicacion = new JColorChooserTest();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}//end main()
}///:~


LAYOUTS
La distribucin de los componentes en un contenedor usualmente esta controlada con
un administrador de diseo (layout manager). Cada contenedor (como un Panel o un
Frame) tiene por omisin un administrador de diseo asociado con este, el cual puede
ser cambiado invocando al mtodo setLayout().
Cada administrador de diseo es responsable de definir el tamao de cada componente
en sus contenedores.
Los siguientes administradores de diseo son incluidos en el lenguaje de programacin
Java:
FlowLayout : Es el administrador de diseo por default en el JPanel y en el
JApplet. Coloca los componentes de izquierda a derecha y de arriba hacia
abajo. Les modifica la posicin pero no les modifica el tamao.
BorderLayout: Es el administrador de diseo por default de JWindow, JDialog
y JFrame. Coloca los componentes en 5 regiones, Norte, Sur, Este, Oeste y
Centro. Modifica tanto la posicin como el tamao de los componentes.
CardLayout: Es raramente usado y coloca los componentes en capas, donde
cada capa es como una carta de naipes, de ah su nombre. Modifica tanto la
posicin como el tamao de los componentes.
GridLayout: Es un administrador de diseo que provee flexibilidad para colocar
componentes a manera de celdillas de una hoja de clculo (Matriz). El tamao de
todas las celdas es igual
GridBagLayout : Es parecido al GridLayout, pero no fuerza a que todos los
componentes tengan el mismo tamao.
La siguiente figura muestra los administradores de diseo (Layout managers).

FlowLayout
Es el administrador de diseo por default para la clase JPanel y los componentes son
agregados de izquierda a derecha. Su alineacin por omisin es centrada y permite
colocar los componentes a sus tamaos preferidos. Con los argumentos del constructor
de FlowLayout se permite definir los componentes para que fluyan de izquierda a
derecha o de derecha a izquierda. Tambin es posible especificar los espacios
mnimos de separacin entre cada componente. Aqu tenemos los constructores:
FlowLayout()
FlowLayout(int align)
FlowLayout(int align, int hgap, int vgap)
Los valores para la alineacin deben ser FlowLayout.LEFT, FlowLayout.RIGHT, o
FlowLayout.CENTER , as por ejemplo:
setLayot( new FlowLayout( FlowLayout.RIGHT, 20, 40 ) );
Crea un administrador de diseo de tipo FlowLayout con una alineacin centrada y con
las unidades de espacios mnimos especificados, por default da 5 unidades para
espacio horizontal y 5 unidades para el vertical.
import java.awt.*;
public class FlowLayoutTest
{
public static void main(String[] args){
f.setTitle("FlowLayoutTest");
f.setSize(300,100);
f.setLayout(new FlowLayout());
JButton b1 = new JButton("Button 1");
f.add(b1);
f.add(b2);
f.add(b3);
f.setVisible(true);
}//end main()
}///:~

import java.awt.*;
public class FlowLayoutTest2
{
f.setTitle("FlowLayoutTest2");
f.setSize(500,150);
f.setLayout(new FlowLayout(FlowLayout.RIGHT,20,40));
f.add(b1);
f.add(b2);
f.add(b3);
f.setVisible(true);
}//end main()
}///:~

BorderLayout
Es el administrador de diseo por default de la clase JFrame. Los componentes son
agregados a 5 regiones especficas dentro de la ventana o frame:
NORTH ocupa la parte de arriba.
SOUTH ocupa la parte inferior.
EAST ocupa el lado derecho.
WEST ocupa la parte izquierda.
CENTER ocupa la parte central.
Cuando ajustamos verticalmente el tamao de la ventana o frame, las regiones EAST,
WEST y CENTER son ajustadas.
Cuando ajustamos horizontalmente el tamao de la ventana o frame, las regiones
NORT, SOUTH y CENTER son ajustadas.
Cuando aadimos botones a las posiciones relativas los botones no cambian si la
ventana es cambiada de tamao, pero los tamaos de los botones si cambian.
El siguiente constructor crea un administrador de diseo de tipo BorderLayout sin
espacios entre sus componentes:
setLayout(new BorderLayout() );
Usando el siguiente constructor podemos indicarle los espacios entre los componentes
especificados por hgap y vgap:
BorderLayout( int hgap, int vgap );
Se deben agregar los componentes en las regiones especficas respetando
maysculas y minsculas ya que no es lo mismo add( boton, BorderLayout.CENTER )
que add( boton, BorderLayout.center ) en el administrador de diseo , o de otra
forma no sern visibles. Si se quiere evitar esto se puede usar add (boton, "center").
Si se deja una regin sin utilizar, esta se comportar como si se hubiera preferido un
tamao de 0 x 0. La regin CENTER seguir apareciendo como fondo cuando incluso
si no tiene componentes.
Ojo: Solo se puede agregar un solo componente por cada una de las cinco regiones. Si
se trata de agregar ms de una, solo la ltima agregada ser la visible. Cuando
deseamos agregar ms componentes por regin usaremos la clase JPanel, lo cual
veremos despus.

import java.awt.*;
public class BorderLayoutTest {
f.setTitle("BorderLayoutTest");
f.setLayout(new BorderLayout());

JButton b1 = new JButton("Button 1 (NORTH)");
f.add(b1,BorderLayout.NORTH);

JButton b2 = new JButton("Button 2 (WEST)");
f.add(b2,BorderLayout.WEST);

JButton b3 = new JButton("Button 3 (CENTER)");
f.add(b3,BorderLayout.CENTER);

JButton b4 = new JButton("Button 4 (EAST)");
f.add(b4,BorderLayout.EAST);

JButton b5 = new JButton("Button 5 (SOUTH)");
f.add(b5,BorderLayout.SOUTH);

f.pack(); // El mtodo pack, hace que el contenedor pregunte a su
f.setVisible(true); // LayoutManager el tamao mnimo para que todos sus
// componentes se puedan ver. Y se ajusten a ese tamao.
}// end main()
}///:~

GridLayout
Este administrador de diseo proporciona flexibilidad para colocar componentes en
celdillas de izquierda a derecha y de arriba a abajo en una rejilla al estilo de una hoja
electrnica de clculo con filas y columnas. Por ejemplo un GridLayout con tres
renglones y dos columnas puede ser creado mediante la sentencia new
GridLayout(3,2) lo que se traduce en 6 celdas.
Con un administrador de tipo GridLayout siempre se ignoran los tamaos preferidos
para cada componente. El ancho de todas celdas es idntico y es determinado
mediante la divisin del ancho disponible sobre el nmero de columnas, as como el alto
de todas las celdas es tambin determinado mediante el alto disponible entre el nmero
de renglones.
El orden en el cual los componentes son agregados a la rejilla es determina la celda
que ocupa. Los renglones de celdas son llenados de izquierda a derecha, como un
texto de una pgina que es llenada con lneas de arriba abajo.

Contenedor Layout Manager
JPanel FlowLayout
JApplet FlowLayout
Jrame BorderLayout
JDialog BorderLayout
JScrollPane FlowLayout
Tabla. Layuts por defecto de los contenedores Swing
import java.awt.*;

public class GridLayoutTest extends JFrame implements ActionListener
{
private JButton botones[];
private final String nombres[] =
{ "uno", "dos", "tres", "cuatro", "cinco", "seis" };
private boolean alternar = true;
private Container contenedor;
private GridLayout cuadricula1, cuadricula2;

// configurar GUI
public GridLayoutTest()
{
super( "GridLayoutTest" );

// establecer esquemas
/*GridLayout()
Creates a grid layout with a default of one column per component,
in a single row.
GridLayout(int rows, int cols)
Creates a grid layout with the specified number of rows and columns.
GridLayout(int rows, int cols, int hgap, int vgap)
Creates a grid layout with the specified number of rows and columns.
*/
cuadricula1 = new GridLayout( 2, 3, 10, 10 );
cuadricula2 = new GridLayout( 3, 2 );

// obtener panel de contenido y establecer su esquema
contenedor = getContentPane();
contenedor.setLayout( cuadricula1 );

// crear y agregar botones
botones = new JButton[ nombres.length ];

for ( int cuenta = 0; cuenta < nombres.length; cuenta++ ) {
botones[ cuenta ] = new JButton( nombres[ cuenta ] );
botones[ cuenta ].addActionListener( this );
botones[ cuenta ].setToolTipText("Cambia el esquema de GridLayout");
contenedor.add( botones[ cuenta ] );
}

setSize( 300, 150 );
setVisible( true );

} // fin del constructor de DemoGridLayout

// manejar eventos de botn, alternando entre los esquemas
{
if ( alternar )
else

alternar = !alternar; // establecer alternar en el valor opuesto
contenedor.validate();// Validates this container and all of its subcomponents.
// Se realiza en cambio fsico de los componentes
}

{
GridLayoutTest aplicacion = new GridLayoutTest();
}//end main()
}///:~

CONTENEDORES DE ALTO NIVEL

Los Componentes no se encuentran aislados, sino agrupados dentro de
Contenedores. Los Contenedores contienen y organizan la situacin de los
Componentes; adems, los Contenedores son en s mismos Componentes y como tales
pueden ser situados dentro de otros Contenedores. Tambin contienen el cdigo
necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de
la aplicacin. Hay dos tipos principales de contenedores: la clase JWindow y JPanel.
Una ventana (JWindow) es un rectngulo que flota libremente en la pantalla. Hay dos
tipos de ventanas. El JFrame y el JDialog. Un JFrame es una ventana con una barra
de titulo y esquinas que pueden ser cambiadas de tamao. Un JDialog es una simple
ventana que no puede tener una barra de men y aunque se puede mover no puede ser
cambiada de tamao.
El JPanel debe estar contenido dentro de otro contenedor, o dentro de una ventana de
un navegador Web. El JPanel es un rea rectangular dentro de la cual se puede colocar
otros componentes.

JDialog
Un JDialog es una ventana que depende de otra ventana (de una JFrame). Si un
JFrame se cierra, se cierran tambin los JDialog que dependen de ella; si se restablece,
sus JDialog aparecen de nuevo. Este comportamiento se obtiene de forma automtica.
Las Applets estndar no soportan JDialogs porque no son Frames de Java. Las Applets
que abren JFrames s pueden soportar JDialogs. Un JDialog modal require la atencin
inmediata del usuario: no se puede hacer ninguna otra cosa hasta no haber cerrado el
JDialog. Por defecto, los JDialogs son no modales.

import java.awt.*;

public class JDialogTest {
private static JFrame ventanaPrincipal;
private static JDialog ventanaSecundaria;

JButton boton = new JButton("Abre secundaria");
// Construccin de ventana principal
ventanaPrincipal = new JFrame("Ventana principal");
ventanaPrincipal.setSize(300,100);
ventanaPrincipal.getContentPane().setLayout(new FlowLayout());
ventanaPrincipal.getContentPane().add(boton);
//ventanaPrincipal.pack();

JButton boton2 = new JButton("Abre principal");
// Construccin de ventana secundaria
ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria");
//ventanaSecundaria = new JDialog(ventanaPrincipal,"Ventana secundaria",true);//modal
ventanaSecundaria.getContentPane().setLayout(new FlowLayout());
ventanaSecundaria.getContentPane().add(boton2);
ventanaSecundaria.setSize(300,100);
//ventanaSecundaria.pack();

// Hacer que el botn abra la ventana secundaria
boton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ventanaSecundaria.setVisible(true);
}
});

// Hacer que el botn abra la ventana principal
boton2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ventanaPrincipal.setVisible(true);
ventanaSecundaria.setVisible(false);
}
});
// Hacer que al cerrarse la secundaria con la x de arriba a la
// derecha, se muestre la primaria
ventanaSecundaria.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
ventanaSecundaria.setVisible(true);
}
});

ventanaPrincipal.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}// end main()
}///:~

CONTENEDORES DE NIVEL INTERMEDIO

JScrollPane
Un JScrollPane provee de un contenedor general que no puede ser usado como un
componente libre. Siempre esta asociado con un contenedor (por ejemplo, un
JFrame). Provee un rea de visualizacin dentro de una regin grande y con barras de
deslizamiento para manipularla.

El JScrollPane crea y maneja las barras de desplazamiento y las contiene en un solo
componente. No es posible controlar el administrador de diseo que usa, en lugar de
esto se puede agregar a un JPanel para que el JScrollPane configure el administrador
de diseo y coloque los componentes en dicho panel.

Ojo: Generalmente, no es posible manejar eventos en un JScrollPane; los eventos son
manejados a travs de los componentes que se contengan.

Se presentan dos versiones diferentes de cdigo fuente de la misma aplicacin
JScrollPaneTest1 y JScrollPaneTest2, para ver las diferentes formas de programar el
mismo cdigo pero con diversa estructura y as poder enriquecer ms la comprensin
de cdigos de Java ya sea para programar nuevas aplicaciones desde cero o entender
y extraer fragmentos de cdigo de otros programadores y adaptarlos a nuestras
necesidades.
import java.awt.*;

public class JScrollPaneTest1 extends JFrame {
private JList listaColores, listaCopia;
private JButton botonCopiar;
private JScrollPane jsp1, jsp2;
private final String nombresColores[] = { "Negro", "Azul", "Cyan",
"Gris oscuro", "Gris", "Verde", "Gris claro", "Magenta", "Naranja",
"Rosa", "Rojo", "Blanco", "Amarillo" };

public JScrollPaneTest1() {
//Pasa el mensaje al constructor del JFrame
super("Listas de seleccin mltiple");
getContentPane().setLayout(new FlowLayout());

// establecer objeto JList listaColores
listaColores = new JList(nombresColores);
listaColores.setVisibleRowCount(5);//Mostrados en el JScrollPane
listaColores.setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

jsp1= new JScrollPane(listaColores);
//getContentPane().add(new JScrollPane(listaColores));

// crear botn copiar y registrar su componente de escucha
botonCopiar = new JButton("Copiar >>>");
getContentPane().add( botonCopiar );
botonCopiar.addActionListener(new ActionListener() {
// manejador del evento del botn
{ // colocar valores seleccionados en listaCopia
listaCopia.setListData(listaColores.getSelectedValues());
}
} // fin de clase interna annima
); // fin de la llamada a addActionListener

// establecer objeto JList listaCopia
listaCopia = new JList();
listaCopia.setVisibleRowCount(5);
listaCopia.setFixedCellWidth(100);
listaCopia.setFixedCellHeight(15);
listaCopia.setSelectionMode(
ListSelectionModel.SINGLE_INTERVAL_SELECTION );

jsp2= new JScrollPane(listaCopia);
//getContentPane().add(new JScrollPane(listaCopia));

setSize(325,130);
setVisible( true );
}// fin constructor JScrollPaneTest1

JScrollPaneTest1 aplicacion = new JScrollPaneTest1();
}// end main()
}///:~

import java.awt.*;

public class JScrollPaneTest2{
private static JList listaColores, listaCopia;
private static JButton botonCopiar;
private static JScrollPane jsp1, jsp2;
private final static String nombresColores[] = { "Negro", "Azul", "Cyan",
"Gris oscuro", "Gris", "Verde", "Gris claro", "Magenta", "Naranja",
"Rosa", "Rojo", "Blanco", "Amarillo" };

public static void main(String args[])
{
JFrame f= new JFrame("Listas de seleccin mltiple");
f.setSize(325,130);

// establecer objeto JList listaColores
listaColores = new JList(nombresColores);
listaColores.setVisibleRowCount(5);//Mostrados en el JScrollPane
listaColores.setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

jsp1= new JScrollPane(listaColores);
f.getContentPane().add(jsp1);
//f.getContentPane().add(new JScrollPane(listaColores));

// crear botn copiar y registrar su componente de escucha
botonCopiar = new JButton("Copiar >>>");
f.getContentPane().add( botonCopiar );
botonCopiar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evento)
{ // colocar valores seleccionados en listaCopia
listaCopia.setListData(listaColores.getSelectedValues());
}
});

// establecer objeto JList listaCopia
listaCopia = new JList();
listaCopia.setVisibleRowCount(5);
listaCopia.setFixedCellWidth(100);
listaCopia.setFixedCellHeight(15);
listaCopia.setSelectionMode(
ListSelectionModel.SINGLE_INTERVAL_SELECTION );

jsp2= new JScrollPane(listaCopia);
f.getContentPane().add(jsp2);
//f.getContentPane().add(new JScrollPane(listaCopia));

f.setVisible( true );
}// end main()
}///:~

JPanel

Los Paneles son los contenedores de propsito general ms frecuentemente utilizados.
Implementados con la clase JPanel, los paneles no aaden casi ninguna funcionalidad
ms all de las que tienen los objetos JComponent. Normalmente se usan para
agrupar componentes, porque los componentes estn relacionados o slo porque
agruparlos hace que la distribucin sea ms sencilla. Un panel puede usar cualquier
controlador de distribucin, y se les puede dotar de bordes fcilmente.

Un Panel es como un Frame y provee del espacio para que el programador coloque
cualquier componente GUI, incluyendo tambin otros paneles. Cada panel hereda de la
clase Container todos sus mtodos y atributos, y puede tener su propio administrador
de diseo.

Ojo: Una de las ventajas de aadir paneles sobre nuestro frame es que los paneles al
derivar de JComponent poseen el mtodo paintComponent() que permite dibujar y
escribir texto sobre el panel de modo sencillo. Adems cuando deseamos agregar ms
componentes en los Layouts por regin (BorderLayout ) usaremos la clase JPanel.

import java.awt.*;

/*JPANEL PARA PINTAR GRAFICAS*/
public class PanelPersonalizado extends JPanel {
/*los miembros y mtodos son public
* para ser llamados por la otra clase*/
public final static int CIRCULO = 1, CUADRADO = 2;
private int figura;

// usar figura para dibujar un valo o rectngulo
public void paintComponent( Graphics g ){
super.paintComponent( g );

if ( figura == CIRCULO )
g.fillOval( 50, 10, 60, 60 );
else if ( figura == CUADRADO )
g.fillRect( 50, 10, 60, 60 );
}

// establecer valor de figura y repintar PanelPersonalizado
public void dibujar( int figuraADibujar )
{
figura = figuraADibujar;
repaint();//llama a paintComponent
}
}///:~
import java.awt.*;
public class JPanelTest extends JFrame
{
private JPanel panelBotones;
private PanelPersonalizado miPanel;
private JButton botonCirculo, botonCuadrado;

// configurar GUI
public JPanelTest()
{
super( "JPanelTest" );
// crear rea personalizada de dibujo
miPanel = new PanelPersonalizado();
miPanel.setBackground( Color.GREEN );

// establecer botonCuadrado
botonCuadrado = new JButton( "Cuadrado" );
botonCuadrado.addActionListener(new ActionListener(){
public void actionPerformed( ActionEvent evento ){
miPanel.dibujar( PanelPersonalizado.CUADRADO );
}
});

botonCirculo = new JButton( "Crculo" );
botonCirculo.addActionListener(new ActionListener(){
miPanel.dibujar( PanelPersonalizado.CIRCULO );
}
});

/*JPANEL PARA AGRUPAR COMPONENTES*/
// establecer panel con botones
panelBotones = new JPanel();
panelBotones.setLayout( new GridLayout( 1, 2 ) );
panelBotones.add( botonCirculo );
panelBotones.add( botonCuadrado );

/* adjuntar panel de botones y rea personalizada
de dibujo al panel de contenido*/
Container contenedor = getContentPane();
contenedor.add( miPanel, BorderLayout.CENTER );
contenedor.add( panelBotones, BorderLayout.SOUTH );
setSize(300,150);
setVisible(true);
} // fin del constructor JPanelTest
{
JPanelTest aplicacion = new JPanelTest();
}//end main()
}///:~

JtabbedPane

Con la clase JTabbedPane, podemos tener varios componentes (normalmente objetos
JPanel) compartiendo el mismo espacio. El usuario puede elegir qu componente ver
seleccionando la pestaa del componente deseado.

Para crear un TabbedPane, simplemente se ejemplariza un JTabbedPane, se crean los
componentes que deseemos mostrar, y luego los aadimos al JTabbedPane utilizando
el mtodo addTab.

import java.awt.*;

public class JTabbedPaneTest extends JFrame {
public JTabbedPaneTest()
{ super("JTabbedPane");

/*SwingConstants:=> A collection of constants generally used for
positioning and orienting components on the screen.
JLabel(String text, int horizontalAlignment)
Creates a JLabel instance with the specified text and horizontal
alignment.*/
JLabel etiqueta1 = new JLabel("panel uno", SwingConstants.CENTER);
JLabel etiqueta2 = new JLabel("panel dos", SwingConstants.CENTER);
JLabel etiqueta3 = new JLabel("panel tres");

// crear objeto JTabbedPane
JTabbedPane panelConFichas = new JTabbedPane();

/* establecer pane11 y agregarlo al objeto JTabbedPane*/
JPanel panel1 = new JPanel();
panel1.add(etiqueta1);
/*addTab(String title, Icon icon, Component component, String tip)*/
panelConFichas.addTab("Ficha uno", null, panel1, "Primer panel");

// establecer panel2 y agregarlo al objeto JTabbedPane
panel2.setBackground(Color.PINK);
panel2.add(etiqueta2);
panelConFichas.addTab("Ficha dos", null, panel2, "Segundo panel");

// establecer panel3 y agregarlo al objeto JTabbedPane
panel3.setLayout(new BorderLayout());
panel3.add( new JButton("Norte"), BorderLayout.NORTH );
panel3.add( new JButton("Sur"), BorderLayout.SOUTH );
panel3.add( new JButton("Oeste"), BorderLayout.WEST );
panel3.add( new JButton("Este"), BorderLayout.EAST );
panel3.add( etiqueta3, BorderLayout.CENTER );
panelConFichas.addTab("Ficha tres", null, panel3, "Tercer panel");

// agregar objeto JTabbedPane al contenedor
getContentPane().add(panelConFichas);

setSize(300, 200);
setVisible( true );

{
JTabbedPaneTest demoPanelConFichas = new JTabbedPaneTest();
demoPanelConFichas.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}// end main()
}///:~


JSplitPane

JSplitPane se usa para dividir con una barrita divisoria dos y solo dos componentes,
mismos que pueden ser alineados de izquierda a derecha o de arriba hacia abajo.
Arrastrando el divisor, el usuario puede especificar qu cantidad de rea pertenece a
cada componente. Un JSplitPane se utiliza cuando dos componentes contienen
informacin relacionada y queremos que el usuario pueda cambiar el tamao de los
componentes en relacin a uno o a otro. Un uso comn de un JSplitPane es para
contener listas de elecciones y una visin de la eleccin actual.


import java.lang.*;
import java.awt.*;

public class JSplitPaneTest1 {
static JFrame f= new JFrame();
static JSplitPane jsplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
static JLabel etiqueta1 = new JLabel("en split1 label1");
static JLabel etiqueta2 = new JLabel("en split2 label2");

f.setTitle("JSplitPane");
f.setSize(300,200);

//cargando jsplitpane con sus dos componentes
jsplitPane.add(etiqueta1);
jsplitPane.add(etiqueta2);

//cargando la ventana con splitpanel
f.getContentPane().add(jsplitPane,BorderLayout.CENTER);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );
f.setVisible(true);
}; //end main()
}///:~

JToolBar

Un objeto JToolBar crea una barra de herramientas con iconos dentro de una fila o una
columna. Normalmente las barras de herramientas proporcionan acceso a
funcionalidades que tambin se encuentran en tems de mens.

import java.awt.*;

public class JToolBarTest {
static JLabel etiqueta = new JLabel();

JFrame f= new JFrame();
f.setTitle("JToolBarTest");
f.setSize(400,150);
f.getContentPane().add(etiqueta,BorderLayout.EAST);

JToolBar toolbar=new JToolBar();
final JButton b1= new JButton(new ImageIcon("open.gif"));
final JButton b2= new JButton(new ImageIcon("save.gif"));
JButton b3= new JButton(new ImageIcon("copy.gif"));
JButton b4= new JButton(new ImageIcon("cut.gif"));
JButton b5= new JButton(new ImageIcon("paste.gif"));
toolbar.add(b1);
toolbar.add(b2);toolbar.addSeparator();
toolbar.add(b3);
toolbar.add(b4);
toolbar.add(b5);

//Forma1: se utiliza la etiqueta dentro del manejador de eventos
//Si se elige el boton de Open en el JToolBar
if (ev.getSource() == b1)
{
etiqueta.setText("Seleccionaste el botn OPEN");
}
}
});

//Forma2: mandamos a llamar a un mtodo openFile() para tratar la etiqueta
//Si se elige el botn de Save en el JToolBar
if (ev.getSource() == b2)
{
openFile();
}
}
});

f.getContentPane().add(toolbar,BorderLayout.NORTH);
f.setVisible(true);
}//end main()

public static void openFile(){
etiqueta.setText("Seleccionaste el botn SAVE");
}
}///:~


MENUS

Un Menu es un componente diferente a otros componentes porque no se puede
agregar a un Menu a los contenedores comunes. Solo se puede agregar mens a un
"menu container".

JMenuBar

Un componente JMenuBar es un men horizontal. Puede solamente agregarse a un
objeto JFrame, y forma la raz de todos los rboles men. Un JFrame despliega un
JMenuBar a la vez. Se puede comenzar un rbol de men poniendo un JMenuBar
"una barra de men" en un JFrame, usando el mtodo setJMenuBar(). Desde este
punto, se pueden agregar mens a la barra de men y mens o elementos de men
dentro del men.

El JMenuBar no soporta oyentes. Como parte normal del comportamiento de un men,
los eventos anticipados que ocurran en la regin de la barra de men son procesados
automticamente.

JMenu

Es posible crear entradas a una barra de men agregando objetos de la clase
JMenu. Los componentes JMenu proveen al JMenuBar elementos de tipo men pull-
down "mens desplegables".


JMenuItem

Un componente JMenuItem son los nodos hoja de un rbol de men. Son agregados a
un men para completarlo. Swing tambin soporta JCheckBox y JRadioButton en
menus, utilizando las clases correspondientes JCheckBoxMenuItem,
JRadioButtonMenuItem.

Si a una aplicacin le quisieramos aadir un men tendramos hacer las siguientes
cosas siguiendo un rden cualquiera:

Crear los objetos JMenuItem.
Crear los objetos JMenu y pegarles los JMenuItem:
(JMenuItem, JCheckBoxMenuItem, JRadioButtonMenuItem)
Crear una JMenuBar y pegarles los JMenu.

Es decir: JMenuBar => contiene JMenu => contiene JMenuItem,
JCheckBoxMenuItem, JRadioButtonMenuItem.


public class JMenuBarTest {
f.setTitle("JMenuBarTest");
f.setSize(250,150);

JMenuBar menuBar=new JMenuBar();
f.setJMenuBar(menuBar); //Sets the menuBar for this frame.

/*NOMBRE DE LOS MENUS*/
// establecer men Archivo y sus elementos de men
JMenu menu1=new JMenu("Menu1"); menu1.setMnemonic('1');
JMenu menu2=new JMenu("Menu2"); menu2.setMnemonic('e');

/*ELEMENTOS DEL MENU1*/
JMenuItem menuItem1= new JMenuItem("Opcion1");
//SE AGREGAN AL menu1
menu1.add(menuItem1);

JCheckBoxMenuItem jcbmenuItem1= new JCheckBoxMenuItem("Opcion1");
JCheckBoxMenuItem jcbmenuItem2= new JCheckBoxMenuItem("Opcion2",true);
JRadioButtonMenuItem jcbmenuItem3= new
JRadioButtonMenuItem("Opcion3",true);
menu2.add(jcbmenuItem1);
menu2.addSeparator(); //Agrega un separador

/*MENU 1 Y MENU2 SE AGREGAN AL MENUBAR*/
menuBar.add(menu1);
menuBar.add(menu2);

f.setVisible(true);
}//end main()
}///:~


import java.awt.*;

public class JMenuBarTest2 extends JFrame {
private final Color valoresColor[]={Color.black,Color.blue,Color.red,Color.green };
private JRadioButtonMenuItem elementosColor[], tiposLetra[];
private JCheckBoxMenuItem elementosEstilo[];
private JLabel pantallaEtiqueta;
private ButtonGroup grupoTiposLetra, grupoColores;
private int estilo;

public JMenuBarTest2(){
super("JMenuBarTest2");

// establecer etiqueta para mostrar texto
pantallaEtiqueta = new JLabel("Texto de ejemplo", SwingConstants.CENTER );
pantallaEtiqueta.setForeground(valoresColor[0]);
pantallaEtiqueta.setFont(new Font("Serif", Font.PLAIN, 72));
getContentPane().add(pantallaEtiqueta, BorderLayout.CENTER);

// crear barra de mens y adjuntarla a la ventana del Frame
JMenuBar barra = new JMenuBar();
setJMenuBar(barra);

JMenu menuArchivo = new JMenu("Archivo");
menuArchivo.setMnemonic('A');

// establecer elemento de men Acerca de...
JMenuItem elementoAcerca = new JMenuItem( "Acerca de..." );
elementoAcerca.setMnemonic('c');
menuArchivo.add(elementoAcerca);
elementoAcerca.addActionListener(new ActionListener(){
// mostrar cuadro de dilogo de mensaje cuando se seleccione Acerca de...
JOptionPane.showMessageDialog(JMenuBarTest2.this,
"ste es un ejemplo\ndel uso de mens",
"Acerca de...", JOptionPane.PLAIN_MESSAGE );
}
});

// establecer elemento de men Salir
JMenuItem elementoSalir = new JMenuItem("Salir");
elementoSalir.setMnemonic('S');
menuArchivo.add(elementoSalir);
elementoSalir.addActionListener(new ActionListener(){
// terminar la aplicacin cuando el usuario haga clic en elementoSalir
{
System.exit(0);
}
});

/*AGREGA LOS MENUITEMS A MENUARCHIVO*/
barra.add(menuArchivo);

// crear men Formato, con sus submens y elementos de men
JMenu menuFormato = new JMenu("Formato");
menuFormato.setMnemonic('F');

// crear submen Color
String colores[] = {"Negro", "Azul", "Rojo", "Verde"};

JMenu menuColor = new JMenu("Color");
menuColor.setMnemonic('C');

elementosColor = new JRadioButtonMenuItem[colores.length];
grupoColores = new ButtonGroup();// Se agrupa para k sean exclusivos
ManejadorEventos manejadorEventos = new ManejadorEventos();

// crear elementos de men tipo botones de opcin para el men Color
for(int cuenta= 0; cuenta < colores.length; cuenta++) {
elementosColor[cuenta]= new JRadioButtonMenuItem(colores[cuenta]);
menuColor.add(elementosColor[cuenta]);
grupoColores.add(elementosColor[cuenta]);
elementosColor[cuenta].addActionListener(manejadorEventos);
}

// seleccionar primer elemento del men Color
elementosColor[0].setSelected(true);

// agregar el Menu Color al Menu Formato de la barra de mens
menuFormato.add(menuColor);
menuFormato.addSeparator();

// crear submen Tipo de letra
String nombresTiposLetra[] = {"Serif", "Monospaced", "SansSerif"};

JMenu menuTiposLetra = new JMenu("Tipo de letra");
menuTiposLetra.setMnemonic('T');

tiposLetra = new JRadioButtonMenuItem[nombresTiposLetra.length];
grupoTiposLetra = new ButtonGroup();

// crear elementos de men tipo botones de opcin para el men Tipos de letra
for ( int cuenta = 0; cuenta < tiposLetra.length; cuenta++ ) {
tiposLetra[cuenta] = new JRadioButtonMenuItem(nombresTiposLetra[cuenta]);
menuTiposLetra.add(tiposLetra[cuenta]);
grupoTiposLetra.add(tiposLetra[cuenta]);
tiposLetra[cuenta].addActionListener(manejadorEventos);
}

// seleccionar el primer elemento del men Tipo de letra
tiposLetra[0].setSelected(true);
menuTiposLetra.addSeparator();

// establecer elementos del men Estilo
String nombresEstilo[]= {"Negrita", "Cursiva"};

elementosEstilo = new JCheckBoxMenuItem[nombresEstilo.length];
ManejadorEstilo manejadorEstilo = new ManejadorEstilo();

// crear elementos de men tipo casilla de verificacin para el men Estilo
for ( int cuenta = 0; cuenta < nombresEstilo.length; cuenta++ ) {
elementosEstilo[cuenta]= new JCheckBoxMenuItem(nombresEstilo[cuenta]);
menuTiposLetra.add(elementosEstilo[cuenta]);
elementosEstilo[cuenta].addItemListener(manejadorEstilo);
}

// colocar men Tipo de letra en el men Formato
menuFormato.add(menuTiposLetra);

// agregar men Formato a la barra de mens
barra.add(menuFormato);

setSize(550, 200);
setVisible(true);


/* clase interna para manejar eventos de accin de los elementos de men
Ambos son JRadioButtonItem */
private class ManejadorEventos implements ActionListener {
// procesar selecciones de color y tipo de letra
{ // procesar seleccin de color
for (int cuenta = 0; cuenta < elementosColor.length; cuenta++)
if (elementosColor[cuenta].isSelected()){
pantallaEtiqueta.setForeground(valoresColor[cuenta]);
break;
}

// procesar seleccin de tipo de letra
for (int cuenta = 0; cuenta < tiposLetra.length; cuenta++)
//if (evento.getSource() == tiposLetra[cuenta]) { //lo mismo
if (tiposLetra[cuenta].isSelected()) {
pantallaEtiqueta.setFont(new Font(tiposLetra[cuenta].getText(), estilo, 72));
break;
}
repaint(); //Repaints this component.
} // fin del mtodo actionPerformed
} // fin de la clase ManejadorEventos

// clase interna para manejar eventos de los elementos de men tipo casilla de verificacin
private class ManejadorEstilo implements ItemListener {
// procesar selecciones de estilo de tipo de letra
estilo = 0;
// checar seleccin de negrita
if (elementosEstilo[0].isSelected())
estilo += Font.BOLD;

// checar seleccin de cursiva
if (elementosEstilo[1].isSelected())
estilo += Font.ITALIC;

pantallaEtiqueta.setFont(
new Font(pantallaEtiqueta.getFont().getName(), estilo, 72));

repaint();//Repaints this component.
}
} // fin de la clase ManejadorEstilo

{
JMenuBarTest2 aplicacion = new JMenuBarTest2();
}// end main()
}///:~
OTRAS CLASES BSICAS

Evento con Teclado

En este apartado se mostrara un ejemplo del manejo de pulsacin de teclas y el mismo
cdigo se mostrar en otras dos clases diferentes para recalcar an ms lo aprendido
en swing y las diversas maneras de programar cdigo Java.

import java.awt.*;

public class KeyListenerTest1 extends JFrame implements KeyListener {
private String linea1 = "", linea2 = "", linea3 = "";
private JTextArea areaTexto;

public KeyListenerTest1()
{
super("Demostracin de eventos de pulsacin de tecla");

// establecer objeto JTextArea
areaTexto = new JTextArea(10,15);
areaTexto.setText("Oprima cualquier tecla en el teclado...");
areaTexto.setEnabled(false);
areaTexto.setDisabledTextColor(Color.blue);
getContentPane().add(areaTexto);

addKeyListener(this); // eventos de teclas para el JTextArea

setSize(400, 100);
setVisible(true);

// manejar evento de pulsacin de cualquier tecla
public void keyPressed(KeyEvent evento)
{ /*getKeyText(int keyCode)=>Returns a String describing the keyCode,
* such as "HOME", "F1" or "A".
* getKeyCode()=>Returns the integer (ASCII)keyCode associated with the key in this event.
*getKeyChar()=> Returns the character associated with the key in this event.*/
//System.out.println(evento.getKeyChar());*/
linea1 = "Se oprimi tecla: " + evento.getKeyText(evento.getKeyCode());
establecerLineas2y3(evento);
}

// manejar evento de liberacin de cualquier tecla
public void keyReleased(KeyEvent evento)
{
linea1 = "Se solt tecla: " + evento.getKeyText(evento.getKeyCode());
}

// manejar evento de pulsacin de una tecla de accin
public void keyTyped(KeyEvent evento)
{
// no hay nada
}

// establecer segunda y tercera lneas de salida
private void establecerLineas2y3(KeyEvent evento)
{ //F1-F12, ImpPant, Inicio, Supr, etc..
linea2 = "Esta tecla " + (evento.isActionKey() ? "" : "no ") +
"es una tecla de accin";

String temp = evento.getKeyModifiersText(evento.getModifiers());

//Ctrl, Shift, Alt, Ctrl+Alt
linea3 = "Teclas modificadoras oprimidas: " +
(temp.equals("") ? "ninguna" : temp);

areaTexto.setText(linea1 + "\n" + linea2 + "\n" + linea3 + "\n");
}

{
KeyListenerTest1 aplicacion = new KeyListenerTest1();
aplicacion.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}//end main()
}///:~
import java.awt.*;

// Se elimino public class KeyListenerTest1 extends JFrame implements KeyListener {
public class KeyListenerTest2 extends JFrame {

// configurar GUI
{

areaTexto = new JTextArea(10, 15);
areaTexto.setText( "Oprima cualquier tecla en el teclado..." );
//areaTexto.setEnabled( false );
areaTexto.setDisabledTextColor( Color.blue );
getContentPane().add( areaTexto );

ManejadorTeclas teclas = new ManejadorTeclas();
//addKeyListener(this); // eventos de teclas para el JTextArea
areaTexto.addKeyListener(teclas); // eventos de teclas para el JTextArea

setSize(400,100);
setVisible( true );

private class ManejadorTeclas implements KeyListener {// manejar evento de pulsacin de
cualquier tecla
* getKeyCode()=>Returns the integer (ASCII)keyCode associated with the key in this
*event.
}

{
}

{
// no hay nada
}




}
}//end manejador

{
}// end main()
}///:~

import java.awt.*;

//Se elimino public class KeyListenerTest1 extends JFrame implements KeyListener {
public class KeyListenerTest3 extends JFrame {

{

areaTexto = new JTextArea(10,15);
areaTexto.setText( "Oprima cualquier tecla en el teclado..." );
areaTexto.setDisabledTextColor(Color.blue);
getContentPane().add(areaTexto);

//ManejadorTeclas teclas = new ManejadorTeclas();
//addKeyListener(this); // eventos de teclas para el JTextArea
areaTexto.addKeyListener(new KeyListener()
{
* getKeyCode()=>Returns the integer (ASCII)keyCode associated with the key in this
* event.
}

{
}

{
// no hay nada
}




}
});

setSize(400, 100 );
setVisible( true );

{
}// end main()
} ///:~

CLASE Color

La clase java.awt.Color encapsula colores utilizando el formato RGB (Red, Green,
Blue). Las componentes de cada color primario en el color resultante se expresan con
nmeros enteros entre 0 y 255, siendo 0 la intensidad mnima de ese color y 255 la
mxima. En la clase Color existen constantes para colores predeterminados de uso
frecuente: black, white, green, blue, red, yellow, magenta, cyan, orange, pink, gray,
darkGray, lightGray.

Se puede construir mediante un valor RGB:
Color amarillo = new Color(255,255,0);
O utilizar colores predefinidos mediante constantes:
Color amarillo = Color.YELLOW;
Soporta transparencias (alpha) mediante un valor entre 0.0 y 1.0

La Tabla muestra algunos mtodos de la clase Color.

import java.awt.*;

public class ColorTest {
f.setTitle("Colores");
f.setSize(200,150);

JLabel etiqueta1=new JLabel("Hola a Todos | ");
JLabel etiqueta2=new JLabel("Hola a Todos");

f.getContentPane().add(etiqueta1);

etiqueta1.setForeground(new Color(255,255,0));
etiqueta2.setForeground(Color.YELLOW);
etiqueta4.setForeground(Color.WHITE);
etiqueta6.setForeground(Color.BLACK);
etiqueta7.setForeground(Color.RED);
etiqueta8.setForeground(Color.BLUE);
etiqueta9.setForeground(Color.GREEN);
etiqueta10.setForeground(Color.GRAY);

f.setVisible(true);
}// end main()
}///:~

CLASE Font

Cada tipo de letra est representado por un objeto de la clase Font. Las clases
Component y Graphics disponen de mtodos setFont() y getFont(). El constructor de
Font tiene la forma:
Font(String name, int style, int size)
Donde el style se puede definir con las constantes:
Font.PLAIN, Font.BOLD y Font.ITALIC
Estas constantes se pueden combinar en la forma: Font.BOLD | Font.ITALIC. La clase
Font tiene tres variables protected, llamadas name, style y size. Adems tiene tres
constantes enteras: PLAIN, BOLD e ITALIC. Esta clase dispone de los mtodos:
String getName(), int getStyle(), int getSize(), boolean isPlain(), boolean isBold() y
boolean isItalic(), cuyo significado es inmediato. Para mayor portabilidad se
recomienda utilizar nombres lgicos de fonts, tales como Serif (Times New Roman),
SansSerif (Arial) y Monospaced (Courier).

import java.awt.*;

public class FontTest {
f.setTitle("FontTest");
f.setSize(180,200);
f.setLayout(new FlowLayout());

JLabel l1 = new JLabel("Serif");
l1.setFont(new Font("Serif", Font.PLAIN, 20));

JLabel l2 = new JLabel("SansSerif");
l2.setFont(new Font("SansSerif", Font.PLAIN, 20));

JLabel l3 = new JLabel("Monospaced");
l3.setFont(new Font("Monospaced", Font.ITALIC, 20));

JLabel l4 = new JLabel("Dialog");
l4.setFont(new Font("Dialog", Font.BOLD,20));

JLabel l5 = new JLabel("DialogInput");
l5.setFont(new Font("DialogInput", Font.BOLD | Font.ITALIC, 20));

f.add(l1); f.add(l2); f.add(l3); f.add(l4); f.add(l5);
f.setVisible(true);
}// end main()
}///:~


CLASE MouseAdapter

Los eventos de Mouse nos cuentan cuando el usuario usa el ratn (o un dispositivo de
entrada similar) para interactuar con un componente. Los eventos Mouse ocurren
cuando el cursor entra o sale del rea de pantalla de un componente, o cuando el
usuario pulsa o libera el botn del ratn. Como seguir la pista del movimiento del ratn
significa mas sobrecarga del sistema que seguir la pista de los eventos de ratn, los
eventos MouseMotion se han separado en otro tipo de oyente
(MouseMotionListener).

El interface MouseListener y su correspondiente clase adaptadora, MouseAdapter,
contienen estos mtodos:

void mouseClicked(MouseEvent): Llamado justo despus de que el usario pulse
sobre el componente escuchado.

void mouseEntered(MouseEvent): Llamado justo despus de que el cursor entre en
los lmites del componente escuchado.

void mouseExited(MouseEvent): Llamado justo despus de que el cursor salga de los
lmites del componente escuchado.

void mousePressed(MouseEvent): Llamado justo despus de que el usuario pulse un
botn del ratn mientras el cursor est sobre el componente escuchado.

void mouseReleased(MouseEvent): Llamado justo despus de que el usuario libere
un botn del ratn despus de una pulsacin sobre el componente esuchado.

import java.awt.*;
public class MouseAdapterTest extends JFrame {
private int xPos, yPos;
private JLabel etiqueta;

public MouseAdapterTest(){
super( "Clics y botones del ratn" );
Container contenedor= getContentPane();
addMouseListener(new ManejadorClicsRaton());

etiqueta= new JLabel("");
contenedor.add(etiqueta);
setSize(450,300);
setVisible(true);

// clase interna para manejar eventos de ratn
private class ManejadorClicsRaton extends MouseAdapter {
// manejar evento de clic del ratn y determinar cul botn se oprimi
public void mouseClicked(MouseEvent evento){
xPos = evento.getX();
yPos = evento.getY();

String titulo = "Se hizo clic " + evento.getClickCount() + " Veces" ;
String titulo2 = "Se hizo clic en: [" + xPos + ", " + yPos + "]";

if (evento.isMetaDown())// botn derecho del ratn
titulo += " con el botn derecho del ratn";
else if (evento.isAltDown())// botn de en medio del ratn
titulo += " con el botn central del ratn";
else // botn izquierdo del ratn
titulo += " con el botn izquierdo del ratn";

etiqueta.setText(titulo2);
setTitle( titulo ); // establecer barra de ttulo de la ventana
} // fin del mtodo mouseClicked
} // fin de la clase interna privada ManejadorClicsRaton

{
MouseAdapterTest aplicacion = new MouseAdapterTest();
}// end main()
}///:~

CLASE ImageIcon

Java permite incorporar imgenes de tipo gif, jpg y png definidas en archivos. Se
dispone para ello de la clase javax.swing.ImageIcon. Algunos componentes Swing,
como JLabel y JButton, pueden ser decorados con un icono -- una imagen de tamao
fijo. En Swing, un icono es un objeto que se adhiere al interface Icon. Swing
proporciona una implementacin particularmente til del interface Icon.

import java.awt.*;

public class ImageIconTest {
f.setTitle("ImageIconTest");
f.setSize(250,100);

JLabel etiqueta1=new JLabel();
// soporta formatos GIF, JPG y PNG
etiqueta1.setIcon(new ImageIcon("save.gif"));

JLabel etiqueta2=new JLabel();
etiqueta2.setIcon(new ImageIcon("open.gif"));

JButton boton1=new JButton("Copiar");
boton1.setIcon(new ImageIcon("copy.gif"));

JButton boton2=new JButton("Pegar");
boton2.setIcon(new ImageIcon("paste.gif"));

f.getContentPane().add(boton1);
f.getContentPane().add(boton2);

f.setVisible(true);
}// end main()
}///:~

CLASE Graphics

La clase Graphics:
Sirve para dibujar (se suele usar con los canvas).
Todos los componentes AWT son dibujados en pantalla a travs del mtodo de
la clase java.awt.Component:
public void paint(Graphics g);
La clase Graphics permite:
Trabajar con primitivas grficas: figuras, colores, textos,
Trabajar con imgenes: GIF y JPEG.
Un componente puede pedir que sea repintado mediante el mtodo:
public void repaint();
Dibujando figuras:
Lneas: drawLine().
Rectngulos: drawRect(), fillRect(), clearRect().
Rectngulos 3D: draw3DRect(), fill3DRect().
Rectng. redondeados: drawRoundRect(), fillRoundRect().
valos: drawOval(), fillOval().
Arcos: drawArc, fillArc().
Polgonos: drawPolygon(), fillPolygon().
Escribiendo texto:
drawBytes(), drawChars(), drawString().

En esta parte final del AWT se van a describir, tambin muy sucintamente, algunas
clases y mtodos para realizar dibujos y aadir texto e imgenes a la interface grfica
de usuario. La clase Component tiene tres mtodos muy importantes relacionados con
grficos: paint(), repaint() y update(). Cuando el usuario llama al mtodo repaint() de
un componente, el AWT llama al mtodo update() de ese componente, que por defecto
llama al mtodo paint().

Mtodo paint(Graphics g)

El mtodo paint() est definido en la clase Component, pero ese mtodo no hace nada
y hay que redefinirlo en una de sus clases derivadas. El programador no tiene que
preocuparse de llamar a este mtodo: el sistema operativo lo llama al dibujar por
primera vez una ventana, y luego lo vuelve a llamar cada vez que entiende que la
ventana o una parte de la ventana debe ser redibujada (por ejemplo, por haber estado
tapada por otra ventana y quedar de nuevo a la vista).

Mtodo update(Graphics g)

El mtodo update() hace dos cosas: primero re-dibuja la ventana con el color de fondo
y luego llama al mtodo paint(). Este mtodo tambin es llamado por el AWT, y tambin
puede ser llamado por el programador, quizs porque ha realizado algn cambio en la
ventana y necesita que se dibuje de nuevo.

La propia estructura de este mtodo -el comenzar pintando de nuevo con el color de
fondohace que se produzca parpadeo (flicker) en las animaciones. Una de las formas
de evitar este efecto es redefinir este mtodo de una forma diferente, cambiando de una
imagen a otra slo lo que haya que cambiar, en vez de re-dibujar todo otra vez desde el
principio. Este mtodo no siempre proporciona los resultados buscados y hay que
recurrrir al mtodo del doble buffer.

Mtodo repaint()

Este es el mtodo que con ms frecuencia es llamado por el programador. El mtodo
repaint() llama lo antes posible al mtodo update() del componente. Se puede
tambin especificar un nmero de milisegundos para que el mtodo update() se llame
transcurrido ese tiempo. El mtodo repaint() tiene las cuatro formas siguientes:

repaint()
repaint(long time)
repaint(int x, int y, int w, int h)
repaint(long time, int x, int y, int w, int h)

Las formas tercera y cuarta permiten definir una zona rectangular de la ventana a la
que aplicar el mtodo.

El nico argumento de los mtodos update() y paint() es un objeto de esta clase. La
clase Graphics dispone de mtodos para soportar dos tipos de grficos:

1. Dibujo de primitivas grficas (texto, lneas, crculos, rectngulos, polgonos, ).
2. Presentacin de imgenes en formatos *.gif y *.jpeg.

Adems, la clase Graphics mantiene un contexto grfico: un rea de dibujo actual, un
color de dibujo del background y otro del foreground, un font con todas sus
propiedades, etc. La siguiente Figura muestra el sistema de coordenadas utilizado en
Java. Como es habitual en Informtica, los ejes estn situados en la esquina superior
izquierda, con la orientacin indicada en la Figura (eje de coordenadas descendente).
Las coordenadas se miden siempre en pixels.


Ejemplo: g.fillRect(25,25,100,20);

Java dispone de mtodos para realizar dibujos sencillos, llamados a veces primitivas
grficas. Como se ha dicho, las coordenadas se miden en pixels, empezando a contar
desde cero. La clase Graphics dispone de los mtodos para primitivas grficas
reseados en la siguiente Tabla. Excepto los polgonos y las lneas, todas las formas
geomtricas se determinan por el rectngulo que las comprende, cuyas dimensiones
son w y h. Los polgonos admiten un argumento de la clase java.awt.Polygon.

La clase Graphics permite dibujar texto, como alternativa al texto mostrado en los
componentes JLabel, JTextField y JTextArea. Los mtodos de esta clase para dibujar
texto son los siguientes:

drawBytes(byte data[], int offset, int length, int x, int y);
drawChars(char data[], int offset, int length, int x, int y);
drawString(String str, int x, int y);

En estos mtodos, los argumentos x e y representan las coordenadas de la lnea base.

import java.awt.*;

public class GraphicsTest1 extends JFrame {
public GraphicsTest1()
{
super( "Uso de los colores" );

setSize(400,130);
setVisible(true);
}

// dibujar rectngulos y objetos String en distintos colores
public void paint(Graphics g)
{
// llamar al mtodo paint de la superclase
super.paint( g );

// establecer nuevo color de dibujo utilizando enteros
g.setColor(new Color(255,0,0));
g.fillRect(25,25,100,20); //(columna,Rengln,ancho,alto);
g.drawString("RGB actual: " + g.getColor(),130,40);
//(String,columna,renglon)

// establecer nuevo color de dibujo utilizando valores float
g.setColor(new Color(0.0f,1.0f,0.0f));
g.fillRect(25,50,100,20);

// establecer nuevo color de dibujo utilizando objetos Color estticos
g.setColor(Color.BLUE);
g.fillRect(25,75,100,20);

// mostrar valores RGB individuales
Color color = Color.MAGENTA;
g.setColor(color);
g.fillRect(25,100,100,20);
g.drawString("Valores RGB: " + color.getRed() + ", " +
color.getGreen() + ", " + color.getBlue(),130,115);
} // fin del mtodo paint

{
GraphicsTest1 aplicacion = new GraphicsTest1();
}// end main()
}///:~

import java.awt.*;
public class MouseAdapterTest2 extends JFrame {
private int xPos, yPos;
//private JLabel etiqueta;

public MouseAdapterTest2(){
super("Clics y botones del ratn");
//Container contenedor= getContentPane();
addMouseListener(new ManejadorClicsRaton());

//etiqueta= new JLabel("");
//contenedor.add(etiqueta);

setSize(450,150);
setVisible(true);

// dibujar objeto String en la ubicacin donde se hizo clic con el ratn
public void paint(Graphics g){
super.paint(g);
g.drawString("Se hizo clic en: [" + xPos + ", " + yPos + "]",xPos,yPos);
}
// clase interna para manejar eventos de ratn
private class ManejadorClicsRaton extends MouseAdapter {
// manejar evento de clic del ratn y determinar cul botn se oprimi
public void mouseClicked(MouseEvent evento){
xPos = evento.getX();
yPos = evento.getY();

String titulo = "Se hizo clic " + evento.getClickCount() + " Veces" ;
//String titulo2 = "Se hizo clic en: [" + xPos + ", " + yPos + "]";

if (evento.isMetaDown())// botn derecho del ratn
titulo += " con el botn derecho del ratn";
else if (evento.isAltDown())// botn de en medio del ratn
titulo += " con el botn central del ratn";
else // botn izquierdo del ratn
titulo += " con el botn izquierdo del ratn";

//etiqueta.setText(titulo2);
setTitle(titulo); // establecer barra de ttulo de la ventana
repaint(); //repinta el componente actual
} // fin del mtodo mouseClicked
} // fin de la clase interna privada ManejadorClicsRaton

{
MouseAdapterTest2 aplicacion = new MouseAdapterTest2();
}// end main()
}///:~

Observar que cada vez que se d clic en un a nueva posicin del JFrame se repinta el
mensaje de las coordenadas.

import java.awt.*;

public class GraphicsTest2 extends JFrame{
public GraphicsTest2(){
setTitle("GraphicsTest");
//setBackground(Color.LIGHT_GRAY);
setSize(300,150);
setVisible(true);
}

public void paint(Graphics g) {
super.paint(g);

//TODOS SOBRE EL RENGLON 35
g.drawLine(15,35,65,65);
g.drawRect(70,35,50,30);
g.drawRoundRect(125,35,50,30,10,10);
g.drawOval(180,35,50,30);
g.drawArc(235,35,50,30,25,200);

int[] x = {15,65,15,65};
int[] y = {90,90,120,120};

//TODOS SOBRE EL RENGLON 90
g.drawPolygon(x,y,x.length);
g.setColor(Color.RED);
g.fillRect(70,90,50,30);
g.fillRoundRect(125,90,50,30,10,10);
g.fillOval(180,90,50,30);
g.fillArc(235,90,50,30,25,200);
g.setColor(Color.BLACK);
g.setFont(new Font("SansSerif",Font.PLAIN,9));

//TODOS LOS MENSAJES EL RENGLON 80
g.drawString("Lnea",30,80);
g.drawString("Rectngulos",95,80);
g.drawString("valo",192,80);
g.drawString("Arco",250,80);

//TODOS LOS MENSAJES EL RENGLON 135
g.drawString("Polgono",22,135);
g.drawString("Rectngulos",95,135);
g.drawString("valo",192,135);
g.drawString("Arco",250,135);
}// end paint()

GraphicsTest2 aplicacion= new GraphicsTest2();
}// end main()
}///:~


CONFIGURANDO EL "Look & Feel" DE UNA APLICACIN

Swing permite cambiar dinmicamente el aspecto y la forma de interaccin de una
aplicacin, por ejemplo el siguiente cdigo modifica el Look & Feel al estilo Java:

// cambiar la apariencia visual
try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
//UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
SwingUtilities.updateComponentTreeUI(f);
}
// procesar problemas al cambiar la apariencia visual
catch ( Exception excepcion ) {
excepcion.printStackTrace();
}

Existen los siguientes Look & Feel:
Java look & feel
CDE/Motif look & feel
Windows look & feel

UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.Windows
LookAndFeel");

UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel
");

UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");


public class LookAndFeelJMenuBarTest {
f.setSize(250,150);

try {
UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
//UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");

//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
SwingUtilities.updateComponentTreeUI(f);
}
}




JRadioButtonMenuItem jcbmenuItem3= new JRadioButtonMenuItem("Opcion3",true);

menuBar.add(menu1);
menuBar.add(menu2);

f.setVisible(true);
}//end main()
}///:~

public class LookAndFeelJMenuBarTest2 {
try {
//se debe de declarar antes de crear una instancia del contenedor
JFrame.setDefaultLookAndFeelDecorated(true);
}
}

f.setSize(250,150);




JRadioButtonMenuItem jcbmenuItem3= new JRadioButtonMenuItem("Opcion3",true);

menuBar.add(menu1);
menuBar.add(menu2);

f.setVisible(true);
}//end main()
}///:~

import java.awt.*;
public class LookAndFeelJMenuBarTest3 extends JFrame
{
public LookAndFeelJMenuBarTest3()
{
super("Ejemplo 1");
JButton boton = new JButton("Mostrar dialogo");
boton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
JOptionPane.showMessageDialog(null,
"Y as- se ve un cuadro de dialogo de error",
"Mensaje",JOptionPane.ERROR_MESSAGE);
}
});
getContentPane().add(new JLabel("Asi se ve un Frame"),
BorderLayout.NORTH);
getContentPane().add(boton);
setSize(200,80);
setVisible(true);
}
{
JFrame.setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated(true);
LookAndFeelJMenuBarTest3 ventana = new LookAndFeelJMenuBarTest3();
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}// end main()
}///:~

APPLETS
Un applet es un programa que se ejecuta mediante un navegador de Internet o con el
programa herramienta del SDK appletviewer.exe. La clase Applet y JApplet son
contenedores visuales de estilo de los Frame y Panel o los JFrame y JPanel. Existen
dos implementaciones: Awt y Swing.
AWT: Se encuentra en el paquete java.applet.*, por tanto, siempre que deseemos
desarrollar un applet deberemos importar este paquete, se encuentra en el paquete
java.applet.*. Hereda de java.awt.Panel. Se le aplican LayoutManagers y se le aaden
componentes como ya hiciermos con los contenedores estndar AWT. Ocurre lo
mismo con la gestin de eventos.
Swing: Se encuentra en el paquete javax.swing.*, por tanto, siempre que deseemos
desarrollar un applet deberemos importar este paquete. Hereda de java.applet.Applet.
Se le aplican LayoutManagers y se le aaden componentes como ya hiciermos con los
contenedores estndar AWT. Ocurre lo mismo con la gestin de eventos.
Los applet tienen la ventaja de ejecutarse en Internet sobre el navegador en el equipo
del cliente, pero los diseadores de Java les colocaron algunas restricciones para evitar
que estos daen, roben informacin del sistema o inserten virus en las mquinas donde
se ejecutan, entre ellas estn:
No pueden leer o escribir en el sistema de archivos desde un navegador.
Solo tienen acceso al servidor definido dentro del applet en un programa que use
sockets.
Impedimento para ejecutar programas en el cliente.
Impedimento para cargar programas nativos incluidas las DLL.

Ciclo de vida de un applet
A diferencia de las aplicaciones Java convencionales, los Applets no tienen un mtodo:
public static void main(String[] args) para ejecutarse. Por el contrario tiene cinco
mtodos que el usuario puede sobreescribir para darle la funcionalidad requerida. Estos
mtodos siguen un ciclo de vida que se explica en el diagrama de abajo, estos mtodos
son:

public void init();
public void start();
public void paint(Graphics g);
public void stop();
public void destroy();

public void init(): Es el primer mtodo que se ejecuta al cargar el applet y slo se
ejecuta una vez. Se debe utilizar para inicializar las variables.
public void start(): Se ejecuta despus del init(). Permite reinicializar un applet
despus de que se haya parado, es decir, arranca el applet (reload, maximizar, etc).
El mtodo start() se ejecuta cada vez que se muestra en pantalla el documento HTML
que contiene el applet. Se suele usar para arrancar procesos.
public void paint(Graphics g): Se ejecuta cada vez que se debe volver a pintar o
escribir la salida de un applet, es decir, se refresca el applet.
public void stop(): se ejecuta cuando el navegador abandona la pgina HTML que
contiene el applet. Se utiliza para parar el applet; para volverlo a iniciar se llama el
mtodo start(). Se suele usar para parar procesos.
public void destroy(): se ejecuta cuando el entorno determina que el applet debe ser
borrado completamente de la memoria o cerrar el navegador web. El mtodo stop()
siempre se ejecuta antes que el destroy. Solo se ejecuta una vez en la vida del applet.
Ojo: En esta clase el mtodo inicial para ejecutar un applet es init() cuando se omite se
usa el mtodo start(), si tambin se omite se usa el mtodo paint() (esto significa que
no requiere de un mtodo main()).

En el ejemplo siguiente se muestra un applet llamado CicloVida que despliega una
serie de mensajes en la consola y en el visualizador del appletviewer, el cual demuestra
el ciclo de vida del applet.

Ejecutarlo con AppletViewer par aver los llamados a la consola de salida. Eclpise los
ejecuta automticamente con dicho ejecutable.
import java.awt.Graphics;
import javax.swing.JApplet;

public class AppletCicloVida extends JApplet {
public AppletCicloVida(){
System.out.println("El constructor se esta ejecutando....");
}

/** Mtodo init del applet. Inicializa el applet. */
public void init(){
System.out.println("Este es el mtodo init().\n");
}

/** Mtodo start. Arranca o comienza el applet */
public void start(){
System.out.println("Este es el mtodo start(). \n");
}

/** Mtodo paint. Dibuja o pinta el applet. */
public void paint(Graphics g){
g.drawString("Hola , a todos mis pupilos!", 10,50);
System.out.println("El applet acaba de ser dibujado con paint() \n");
}

/** Mtodo stop. Para el applet. */
public void stop(){
System.out.println("Este es el mtodo stop(), para el applet. \n");
}

/** Mtodo destroy. Destructor del applet. */
public void destroy(){
System.out.println("Este es el mtodo destroy(), destruye el applet.\n");
}
}///:~

AppletCicloVida.html

<html>
<head>
<title>CHECA EL CICLO DE VIDA DEL APPLET</title>
</head>
<body>
<APPLET CODE= "AppletCicloVida.class" WIDTH="200" HEIGHT="150">
</APPLET>
</body>
</html>

Cuando se ejecuta por primera vez la aplicacin manda a llamar en el siguiente orden a
los mtodos init(), seguido de start() y por ltimo al mtodo paint().

Luego se abrio una ventana de otra aplicacin la cual era ms grande que la del Applet,
y se selecciono para hacerla visible dando clic en la ventana minimizada en a barra de
tareas de Windows. Con esto se ejecut el mtodo paint(). Para este ejemplo se hizo lo
mismo 4 veces ms obteniendose en la salida de la consola 4 veces el mtodo paint().

Ahora se minimizo la ventana del Applet y se ejecuto el mtodo stop().

Cuando se restauro de nueva cuanta el Applet se ejecutaron los mtodos start() y
paint().

Cuando se maximiza la ventana manda a ejecutar al mtodo paint().


Despus de Maximizar al restaurar manda a llamar al mtodo paint().

Si se agranda o achica la ventana con el Mouse manda a llamar al mtodo paint().

Al cerrar la ventana del Applet manda a llamar al mtodo stop() y despus al destroy().

El tag Applet en HTML
Los applets son ejecutados mediante un navegador (Internet Explorer, Netscape,
Opera, etc.) o con el appletviewer, pero esto es realizado mediante un archivo con
extensin HTML. En este archivo debe tener la etiqueta o tag <APPLET></APPLET>
con la siguiente estructura:
Nota: El nombre del archivo (ArchivoClase.html) deber llevar el mismo nombre
del archivo (ArchivoClase.class) a utilizar.
Archivo.html
<APPLET
Code = "Nombre archivo de clase"
CodeBase = "Ruta (URL) a los archivos de clase"
Align = "Alineacin del Applet"
Width = "Ancho en pixeles del Applet"
Height = "Alto en pixeles del Applet" >
<PARAM name = "nombre del parmetro" value = "valor del parmetro">
</APPLET>
En la etiqueta <APPLET></APPLET> algunos argumentos permiten modificar la
ubicacin del espacio que ocupa el applet en una pgina Web, algunos de estos
atributos son:
ALIGN, determina la alineacin del applet, los valores que toma son: LEFT, RIGHT,
TEXTTOP, MIDDLE, BASELINE, BOTTOM, ABSBOTTOM, TOP, ABSMIDDLE, as por
ejemplo, <APPLET ALIGN=LEFT> coloca el applet haca la izquierda y el texto adelante
del mismo. Si agregamos la etiqueda <BR> el texto se coloca despus del applet si se
incluye el atributo CLEAR el cual toma los valores LEFT para colocar el texto en el
siguiente margen izquierdo disponible, RIGHT para el margen derecho y ALL en la
siguiente lnea donde ambos mrgenes estn disponibles.
HSPACE, indica el espacio horizontal entre el applet y el texto que lo rodea.
VSPACE, indica el espacio vertical entre el applet y el texto que lo rodea.
CODEBASE, contiene la ruta de las clases del applet, si se omite se considera
el mismo directorio de la pgina Web.
PARAM, contiene una pareja de NAME y VALUE para enviar parmetros al
applet, y pueden ser uno o mas etiquetas PARAM.
En Java los programas que se ejecutan en el cliente se llaman applets y los que se
ejecutan del lado del servidor se llaman servlets.

import java.awt.Graphics;
import java.util.Date;

public class AppletTest2 extends JApplet
{
public void paint( Graphics g )
{
g.drawString("Hola alumnos, su curso de ",25,20);
g.drawString("applets, con swing, y awt ",25,35);
g.drawString("a comenzado hoy => " + new Date(),25,50);
}
}///:~

AppletTest2.html

<HTML>
<HEAD>
<TITLE>Applet Hola</TITLE>
</HEAD>
<BODY>
<P>Applet con javax.swing de bienvenida</P>
<APPLET CODE=AppletTest2.class WIDTH=500 HEIGHT=100>
</APPLET>
</BODY>
</HTML>


En el siguiente ejemplo se crea una aplicacin convencional con JFrame y despus es
pasada a Applet para identificar qu partes del cdigo fuente sufren cambios para que
sea interpretada como applet.

import java.awt.*;

public class JFrameDialogMessage extends JFrame implements ActionListener
{
JButton jbutton1 = new JButton("Mostrar dilogo de informacin");
JButton jbutton2 = new JButton("Mostrar dilogo de error");
JButton jbutton3 = new JButton("Mostrar dilogo de aviso");
JButton jbutton4 = new JButton("Mostrar dilogo de pregunta");
JButton jbutton5 = new JButton("Mostrar dilogo simple");

public JFrameDialogMessage()
{
setSize(220,230);
setLayout(new FlowLayout());
setVisible(true);

getContentPane().add(jbutton1);

jbutton1.addActionListener(this);
}

public void actionPerformed(ActionEvent e)
{
String dialogtitle = "Dilogo";
String dialogmessage = "Hola desde Swing!";
int dialogtype = JOptionPane.PLAIN_MESSAGE;

if(e.getSource() == jbutton1) {
dialogtype = JOptionPane.INFORMATION_MESSAGE;
} else if(e.getSource() == jbutton2) {
dialogtype = JOptionPane.ERROR_MESSAGE;
dialogtype = JOptionPane.WARNING_MESSAGE;
dialogtype = JOptionPane.QUESTION_MESSAGE;
dialogtype = JOptionPane.PLAIN_MESSAGE;
}

JOptionPane.showMessageDialog((Component) null,
dialogmessage, dialogtitle, dialogtype);
}

JFrameDialogMessage f = new JFrameDialogMessage();
}
}///:~
El mismo ejemplo version Applet.

import java.awt.*;
/*
<APPLET
CODE = JAppletDialogMessage.class
WIDTH = 350
HEIGHT = 280 >
</APPLET>
*/
//public class JAppletDialogMessage extends JFrame implements ActionListener
public class JAppletDialogMessage extends JApplet implements ActionListener
{
JButton jbutton1 = new JButton("Mostrar dilogo de informacin");
JButton jbutton2 = new JButton("Mostrar dilogo de error");
JButton jbutton3 = new JButton("Mostrar dilogo de aviso");
JButton jbutton4 = new JButton("Mostrar dilogo de pregunta");
JButton jbutton5 = new JButton("Mostrar dilogo simple");

public void init()
{
//setSize(220,230);
setLayout(new FlowLayout());
//setVisible(true);


}

public void actionPerformed(ActionEvent e)
{
String dialogtitle = "Dilogo";
String dialogmessage = "Hola desde Swing!";
int dialogtype = JOptionPane.PLAIN_MESSAGE;

if(e.getSource() == jbutton1) {
dialogtype = JOptionPane.INFORMATION_MESSAGE;
dialogtype = JOptionPane.ERROR_MESSAGE;
dialogtype = JOptionPane.WARNING_MESSAGE;
dialogtype = JOptionPane.QUESTION_MESSAGE;
dialogtype = JOptionPane.PLAIN_MESSAGE;
}

JOptionPane.showMessageDialog((Component) null,
dialogmessage, dialogtitle, dialogtype);
}

/*public static void main(String[] args){
JFrameDialogMessage f = new JFrameDialogMessage();
}*/
}///:~


Paso de parmetros a un applet desde HTML
En un applet es posible recibir parmetros desde la pgina Web de HTML con la
etiqueta <APPLET> que lo invoca mediante el mtodo
getParameter("argumento") . Este mtodo devolver el valor del "argumento" como
un objeto de la clase String. Los parmetros son enviados dentro de la etiqueta
<APPLET> con <PARAM NAME = "argumento" VALUE = "elvalor" > y no est
limitada a un solo parmetro, pueden ser varios parmetros los que se enven, por
ejemplo:

<APPLET CODE = "AppletgetParameter.class" WIDTH=400 HEIGHT=100>
<PARAM NAME="figura" VALUE= "circulo" >
<PARAM NAME="radio" VALUE= "50.0" >
</APPLET>
Donde estamos enviando dos parmetros; uno llamado "figura" y otro "radio" con sus
valores "circulo" y "50.0" respectivamente. Como el mtodo getParameter() regresa
un objeto de la clase String, en el caso de "50.0" , este ser una cadena y no un
nmero, esto es, no ser un valor de tipo double o float, si queremos convertirlo a esos
tipos hay que utilizar mtodos de conversin de tipos disponibles en las clases Wrapper
Double o Float.

Ejemplos con el mtodo getParameter()

En el siguiente applet de ejemplo se calcula el rea de un crculo o de un cuadrado
y se dibuja la figura dependiendo del valor recibido en el parmetro "figura", si este
valor es "circulo", dibujar un circulo y obtendr su rea, pero si el valor es "cuadrado"
entonces dibujar un cuadrado y calcular su rea:

import java.awt.*;

public class AppletgetParameter extends JApplet {
public void paint( Graphics g ) {
String figura;
float radio;
float lado;
double areacirculo, areacuadrado;

// LEE LOS PARAMETROS DE HTML name Y value
figura = getParameter("figura");
if(figura.equals("circulo")) {
radio= new Float(getParameter("radio")).floatValue();
areacirculo = Math.PI * radio * radio;
g.drawString("El area de un "+ figura + " de radio "
+ radio + " = " + areacirculo,15,20);
g.setColor(Color.RED);
g.drawOval(100,30,(int)radio,(int)radio);
g.setColor(Color.CYAN);
g.fillOval(100,30,(int)radio - 1,(int)radio - 1);
}
else if(figura.equals("cuadrado")) {
lado= new Float(getParameter("lado")).floatValue();
areacuadrado = lado * lado;
g.drawString("El area de un "+ figura + " de lado "
+ lado + " = " + areacuadrado,15,20);
g.drawRect(100,30,(int)lado,(int)lado);
g.setColor(new Color(00,21,00));/* establece color verde muy obscuro */
g.fillRect(100+1,30+1,(int)lado-1,(int)lado-1); /* dibuja borde */
}
else {
g.drawString("Lo siento no hay ninguna figura",15, 20 );
}
}//end paint ()
}///:~

En este caso el archivo HTML con el que se invoca el applet tiene dos etiquetas
<APPLET> y cada una con un parmetro "figura" que es el parmetro que se le enva
al programa en Java el cual extrae su valor con el mtodo getParamenter() y en una
sentencia if se decide cual figura dibujar.

AppletgetParameter.html

<HEAD>
<TITLE>Applet con parmetros</TITLE>
</HEAD>
<BODY>
<P>Applet que desplega un el area de una figura y la dibuja</P>
<P>Ahora voy a dibujar una figura=circulo</P>
<PARAM NAME="figura" VALUE= "circulo" >
<PARAM NAME="radio" VALUE= "50.0" >
</APPLET>
<PARAM NAME="figura" VALUE= "cuadrado" >
<PARAM NAME="lado" VALUE= "50.0" >
</APPLET>
</BODY>
</HTML>

173840-Programaci N GR Fica Con Swing Emmanuel Rivera

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

173840-Programaci N GR Fica Con Swing Emmanuel Rivera

Enviado por

Direitos autorais:

Formatos disponíveis

12.

Programacin Grfica Con Swing

Você também pode gostar