JSEPARATOR

JSeparator proporciona un componente de propósito general para la aplicación de las líneas de división - más comúnmente utilizado como divisor entre los elementos del menú que les divide en grupos lógicos utilizando. En lugar de JSeparator directamente, puede utilizar el JMenu o JPopupMenu addSeparator método para crear y agregar un separador. JSeparator s también puede tener otros usos en una interfaz gráfica de usuario siempre que sea un divisor visual es útil./ / Cuando la interfaz gráfica de usuario se crea:JMenuBar menuBar; JMenuBar menuBar;JMenu menu, submenu; JMenu menú , submenú;JMenuItem menuItem; JMenuItem menuItem;JRadioButtonMenuItem rbMenuItem; JRadioButtonMenuItem rbMenuItem;JCheckBoxMenuItem cbMenuItem; JCheckBoxMenuItem cbMenuItem;

//Create the menu bar. / / Crear la barra de menús.menuBar = new JMenuBar(); menuBar = JMenuBar nuevo ();

//Build the first menu. / / Construye el primer menú.menu = new JMenu("A Menu"); menú = new JMenu ("un menú");menu.setMnemonic(KeyEvent.VK_A); menu.setMnemonic (KeyEvent.VK_A);menu.getAccessibleContext().setAccessibleDescription( menu.getAccessibleContext (). setAccessibleDescription ( "The only menu in this program that has menu items"); "El menú sólo en este programa que tiene elementos de menú");menuBar.add(menu); menuBar.add (menú);

//a group of JMenuItems / / Un grupo de JMenuItemsmenuItem = new JMenuItem("A text-only menu item" , menuitem = JMenuItem nuevo ("Un solo elemento de menú de texto", KeyEvent.VK_T ); KeyEvent.VK_T);menuItem.setAccelerator(KeyStroke.getKeyStroke( menuItem.setAccelerator (KeyStroke.getKeyStroke ( KeyEvent.VK_1, ActionEvent.ALT_MASK)); ActionEvent.ALT_MASK KeyEvent.VK_1,));menuItem.getAccessibleContext().setAccessibleDescription( menuItem.getAccessibleContext (). setAccessibleDescription ( "This doesn't really do anything"); "Esto en realidad no hacer nada");menu.add(menuItem); menu.add (menuItem);

menuItem = new JMenuItem("Both text and icon", menuitem = JMenuItem nuevo ("Tanto el texto y el icono", new ImageIcon("images/middle.gif")); nueva ImageIcon ("images / middle.gif"));menuItem.setMnemonic(KeyEvent.VK_B); menuItem.setMnemonic (KeyEvent.VK_B);menu.add(menuItem); menu.add (menuItem);

menuItem = new JMenuItem(new ImageIcon("images/middle.gif")); menuitem = JMenuItem nuevo (ImageIcon nueva ("images / middle.gif"));menuItem.setMnemonic(KeyEvent.VK_D); menuItem.setMnemonic (KeyEvent.VK_D);menu.add(menuItem); menu.add (menuItem);

//a group of radio button menu items / / Un grupo de elementos de menú de radio botónmenu.addSeparator(); menu.addSeparator ();ButtonGroup group = new ButtonGroup(); ButtonGroup grupo = new ButtonGroup ();rbMenuItem = new JRadioButtonMenuItem("A radio button menu item"); rbMenuItem = JRadioButtonMenuItem nuevo ("Un botón de menú");

rbMenuItem.setSelected(true); rbMenuItem.setSelected (true);rbMenuItem.setMnemonic(KeyEvent.VK_R); rbMenuItem.setMnemonic (KeyEvent.VK_R);group.add(rbMenuItem); group.add (rbMenuItem);menu.add(rbMenuItem); menu.add (rbMenuItem);

rbMenuItem = new JRadioButtonMenuItem("Another one"); rbMenuItem = JRadioButtonMenuItem nuevo ("Otro");rbMenuItem.setMnemonic(KeyEvent.VK_O); rbMenuItem.setMnemonic (KeyEvent.VK_O);group.add(rbMenuItem); group.add (rbMenuItem);menu.add(rbMenuItem); menu.add (rbMenuItem);

//a group of check box menu items / / Un grupo de elementos de verificación menú de la cajamenu.addSeparator(); menu.addSeparator ();cbMenuItem = new JCheckBoxMenuItem("A check box menu item"); cbMenuItem = JCheckBoxMenuItem nuevos ("Una casilla de verificación elemento de menú");cbMenuItem.setMnemonic(KeyEvent.VK_C); cbMenuItem.setMnemonic (KeyEvent.VK_C);menu.add(cbMenuItem); menu.add (cbMenuItem);

cbMenuItem = new JCheckBoxMenuItem("Another one"); cbMenuItem = JCheckBoxMenuItem nuevo ("Otro");cbMenuItem.setMnemonic(KeyEvent.VK_H); cbMenuItem.setMnemonic (KeyEvent.VK_H);menu.add(cbMenuItem); menu.add (cbMenuItem);

//a submenu / / Un submenúmenu.addSeparator(); menu.addSeparator ();submenu = new JMenu("A submenu"); submenu = new JMenu ("Un submenú");submenu.setMnemonic(KeyEvent.VK_S); submenu.setMnemonic (KeyEvent.VK_S);

menuItem = new JMenuItem("An item in the submenu"); menuitem = JMenuItem nuevo ("Un elemento en el submenú");menuItem.setAccelerator(KeyStroke.getKeyStroke( menuItem.setAccelerator (KeyStroke.getKeyStroke ( KeyEvent.VK_2, ActionEvent.ALT_MASK)); KeyEvent.VK_2, ActionEvent.ALT_MASK));submenu.add(menuItem); submenu.add (menuItem);

menuItem = new JMenuItem("Another item"); menuitem = JMenuItem nuevo ("Otro tema");submenu.add(menuItem); submenu.add (menuItem);menu.add(submenu); menu.add (submenú);

//Build second menu in the menu bar. / / Construir segundo menú en la barra de menú.menu = new JMenu("Another Menu"); menú = new JMenu ("otro menú");menu.setMnemonic(KeyEvent.VK_N); menu.setMnemonic (KeyEvent.VK_N);menu.getAccessibleContext().setAccessibleDescription( menu.getAccessibleContext (). setAccessibleDescription ( "This menu does nothing"); "Este menú no hace nada");menuBar.add(menu); menuBar.add (menú);

... ...frame.setJMenuBar( ); frame.setJMenuBar (theJMenuBar);

As the code shows, to set the menu bar for a , you use the method. To add a to a , you use the method. To add menu items and submenus to a , you use the method.El JSpinner

El JSpinner es un componente java en el que se presenta una caja de texto con dos flechitas en el lado derecho, una hacia arriba y la otra hacia abajo. En el campo de texto se muestra un valor. Con las flechitas arriba y abajo podemos incrementar o decrementar ese valor.

El siguiente es un código de ejemplo de uso de JSpinner. Se muestra una ventana con un JSpinner y un JTextField. Al JSpinner se le añade un addChangeListener() de forma que nos enteramos de los cambios de valor en dicho componente. En ese listener nos encargamos de meter en el JTextField el nuevo valor del JSpinner. El resultado es que según cambiamos valores en el JSpinner, van apareciendo en nuestro JTextField.

/* * Ejemplo sencillo de JSpinner. * Chuidiang 27 Oct 2007 */package chuidiang.ejemplos;

import java.awt.FlowLayout;

import javax.swing.JFrame;import javax.swing.JSpinner;import javax.swing.JTextField;import javax.swing.WindowConstants;import javax.swing.event.ChangeEvent;import javax.swing.event.ChangeListener;

/** * Ejemplo de uso de JSpinner. * Se crea una ventana con un JSpinner y un JTextField. El valor * seleccionado en el JSpinner pasa automáticamente al JTextField. * @author chuidiang */public class PruebaJSpinner {

/** El JTextField */private JTextField tf;

/** El JSpinner */private JSpinner spinner;

/** La ventana */private JFrame v;

/** * Crea una instancia de esta clase. * @param args */public static void main(String[] args) {

new PruebaJSpinner();}

/** * Crea la ventana con el JSpinner y el JTextField. La visualiza.

*/public PruebaJSpinner(){

// Creacion del JTextFieldtf = new JTextField(20);

// Creacion del JSpinner y valor incial.spinner = new JSpinner();spinner.setValue(30);

// Nos suscribimos a cambios en el JSpinnerspinner.addChangeListener(new ChangeListener() {

@Overridepublic void stateChanged(ChangeEvent e) {

// Ponemos el valor del JSpinner en el JTextFieldtf.setText(spinner.getValue().toString());

}

});

// Creacion de la ventana con los componentesv = new JFrame();v.getContentPane().setLayout(new FlowLayout());v.getContentPane().add(spinner);v.getContentPane().add(tf);v.pack();v.setVisible(true);v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

}}

JSCROLLBAR

This Java Swing tip illustrates a method of implementing a scrollbar in both vertical and horizontal direction. Developer may implement this in their applications to provide easy browsing functionality to their users for navigating long documents. Developer may supply the orientation (via JSlider.HORIZONTAL or JSlider.VERTICAL) and the range and initial value to the constructor.

Esta punta de Oscilación Javanesa ilustra un método de poner en práctica un scrollbar tanto en la dirección vertical como en horizontal. El revelador puede poner en práctica esto en sus usos para proporcionar la funcionalidad fácil que hojea a sus usuarios para navegar documentos largos. El revelador puede suministrar la orientación (vía JSLIDER. HORIZONTAL O JSLIDER. VERTICAL) y la gama y la inicial valoran al constructorimport java.awt.*;import java.awt.event.*;import javax.swing.*;

public class ScrollBarExample extends JPanel { JLabel label; public ScrollBarExample() {

super(true); label=new JLabel(); setLayout(new BorderLayout()); JScrollBar hbar = new JScrollBar( JScrollBar.HORIZONTAL, 30, 20, 0, 300); JScrollBar vbar = new JScrollBar( JScrollBar.VERTICAL, 30, 40, 0, 300); hbar.setUnitIncrement(2); hbar.setBlockIncrement(1); hbar.addAdjustmentListener(new MyAdjustmentListener()); vbar.addAdjustmentListener(new MyAdjustmentListener()); add(hbar, BorderLayout.SOUTH); add(vbar, BorderLayout.EAST); add(label, BorderLayout.CENTER); } class MyAdjustmentListener implements AdjustmentListener { public void adjustmentValueChanged(AdjustmentEvent e) { label.setText(" New Value is " + e.getValue() + " "); repaint(); } } public static void main(String s[]) { JFrame frame = new JFrame("Scroll Bar Example"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setContentPane(new ScrollBarExample()); frame.setSize(200,200); frame.setVisible(true); }}

JSCROLLPANE

Tambien es swing.

Cuando un componente ocupa mucho espacio en pantalla o contiene mucha información, un JSCROLLPANE permite asociarle una pequeña vista o ventana deslizable o corrediza que permite solo que se vea una parte de dicho componente. Un JSCROLLPANE, tambien puede asociarse a otros tipos de panels que contengan muchos componentes.import java.lang.*;import java.awt.*;import java.awt.event.*;import javax.swing.*;

public class prog9 {

//declaracion, creacion e inicializacion de componentes, objetos y variables

static JFrame ventana= new JFrame();

static JScrollPane panel1 = new JScrollPane();

static JTextField jt1 = new JTextField(80);

// parte principal de programa

public static void main(String[] args)

{ // area de definicion de propiedades de el objeto

ventana.setTitle("mi programa");

ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE);

//cargando scrollpane panel1 con un componente grandote

panel1.setViewportView(jt1);

// cargando la ventana con el scrollpanel

ventana.getContentPane().add(panel1,BorderLayout.CENTER);

ventana.pack(); ventana.setVisible(true);

//area de asociacion de objeto-eventos

}; // termina main

} // termina clase

JLIST

El ejemplo ListDemo que mostramos anteriormente dispone de una lista cuyos contenidos pueden cambiar. Usted puede encontrar el código fuente de ListDemo en ListDemo.java . Aquí está el código ListDemo que crea un objeto de lista de modelos mutables, pone los puntos iniciales en él, y utiliza el modelo de lista para crear una lista: listModel = new DefaultListModel();listModel.addElement("Jane Doe");listModel.addElement("John Smith");listModel.addElement("Kathy Green");

list = new JList(listModel);Este programa especial de una instancia de DefaultListModel , una clase que proporciona Swing. A pesar del nombre de la clase, una lista no tiene DefaultListModel a menos que su programa explícitamente lo hace así. Si DefaultListModel no satisface sus necesidades, usted puede escribir una costumbre modelo de lista, que deberá atenerse a las ListModel interfaz.

El fragmento de código siguiente se muestra el actionPerformed método para la escucha de la acción registrada en el botón de fuego. La línea gruesa de código quita el elemento seleccionado en la lista. El resto

de líneas en el método de deshabilitar el botón de disparo si la lista está vacía, y hacer otra selección si no lo es. public void actionPerformed(ActionEvent e) { int index = list.getSelectedIndex(); listModel.remove(index);

int size = listModel.getSize();

if (size == 0) { //Nobody's left, disable firing. fireButton.setEnabled(false);

} else { //Select an index. if (index == listModel.getSize()) { //removed item in last position index--; }

list.setSelectedIndex(index); list.ensureIndexIsVisible(index); }}

Aquí está el actionPerformed método para el oyente de acción compartida por el botón de alquiler y el campo de texto:

public void actionPerformed(ActionEvent e) { String name = employeeName.getText();

//User did not type in a unique name... if (name.equals("") || alreadyInList(name)) { Toolkit.getDefaultToolkit().beep(); employeeName.requestFocusInWindow(); employeeName.selectAll(); return; }

int index = list.getSelectedIndex(); //get selected index if (index == -1) { //no selection, so insert at beginning index = 0; } else { //add after the selected item index++; }

listModel.insertElementAt(employeeName.getText(), index);

//Reset the text field. employeeName.requestFocusInWindow(); employeeName.setText("");

//Select the new item and make it visible. list.setSelectedIndex(index); list.ensureIndexIsVisible(index);}

Este código utiliza el modelo de lista de insertElementAt método para insertar el nuevo nombre después de la selección actual o, si no hay selección, al principio de la lista. Si lo que desea añadir a la final de la lista, puede utilizar DefaultListModel s ' addElement método en lugar.

Cada vez que se agregan elementos a, eliminado de, o modificados en una lista, el modelo de lista de los incendios de datos lista de eventos. Consulte Cómo escribir una lista de datos de escucha para obtener información sobre música para estos eventos. Esta sección contiene un ejemplo que es similar a ListDemo , pero agrega botones que hasta artículos o abajo se mueven en la lista

JFileChooser

Uso básico del JFileChooser

JFileChooser es una clase java que nos permite mostrar fácilmente una ventana para la selección de un fichero.

Si queremos abrirlo para leer el fichero, podemos llamarlo así JFileChooser fileChooser = new JFileChooser();int seleccion = fileChooser.showOpenDialog(areaTexto);

A la vuelta, en seleccion tendremos

JFileChooser.CANCEL_OPTION Si el usuario le ha dado al botón cancelar.

JFileChooser.APPROVE_OPTION Si el usuario le ha dado al botón aceptar

JFileCHooser.ERROR_OPTION Si ha ocurrido algún error.

Comprobando que se ha dado al botón aceptar, podemos obtener el fichero seleccionado por el usuario así if (seleccion == JFileChooser.APROVE_OPTION){ File fichero = fileChooser.getSelectedFile(); // Aquí debemos abrir y leer el fichero. ...}

Para seleccionar un fichero para guardar datos, el mecanismo es igual, pero se llama al método showSaveDialog() JFileChooser fileChooser = new JFileChooser();int seleccion = fileChooser.showSaveDialog(areaTexto);if (seleccion == JFileChooser.APPROVE_OPTION){ File fichero = fileChooser.getSelectedFile(); // Aquí debemos abrir el fichero para escritura // y salvar nuestros datos. ...}

La única diferencia entre uno y otro es la etiqueta del diálogo y de los botones. Uno pondrá "Abrir" y otro "Guardar"

Algo de configuración

El JFileChooser se abre por defecto en el directorio HOME del usuario (C:\Documents and Settings\usuario en Windows, /home/usuario en linux). Podemos elegir el directorio en el que queremos que se abra llamando al método setCurrentDirectory() pasando el directorio en cuestión.

Por defecto, un JFileChooser sólo permite elegir ficheros. Si queremos que permita elegir también directorios, debemos llamar a setFileSelectionMode(), pasando como parámetro uno de las siguientes constantes

JFileChooser.FILES_ONLY

JFileChooser.DIRECTORIES_ONLY

JFileChooser.FILES_AND_DIRECTORIES

Filtrar los ficheros visibles

Si no queremos que el JFileChooser muestre todos los ficheros del directorio, podemos añadirle un filtro. Básicamente hay que hacer una clase que herede de FileFilter y definir el método accept(). Este método recibe un parémetro File y nosotros debemos decidir si pasa o no el filtro, devolviendo true o false. Por ejemplo, si sólo queremos ver fichero .jpg, podemos hacer este filtro import javax.swing.filechooser.FileFilter;...public class FiltroDeJPG extends FileFilter{ public boolean accept (File fichero) { if (tieneExtensionJPG (fichero)) return true; else return false; } public String getDescription() { return ("Filtro JPGs"); }}

Debemos definir ambos métodos. La descripción puede ser cualquier cadena de texto que nos sirva como descripción del filtro. Finalmente, debemos pasar este filtro al JFileChooser fileChooser.setFilter(new FiltroDeJPG());

Sin embargo, una de las bondades ofrecidas por el JDK 1.6, es el ahorro en la codificación de una clase filtro, pues este, ya viene con una incluida a la cual solo necesitamos invocarla, la sintaxis es la siguiente: JFileChooser jf = new JFileChooser();FileNameExtensionFilter filter = new FileNameExtensionFilter("JPG & GIF", "jpg", "gif");jf.setFilter(filter);

Donde el primer termino es la descripción y los siguientes serían los tipos de archivos aceptados.

JTree

En este tutorial vamos a ver un ejemplo sencillo de cómo usar el JTree en java.

El JTree es el componente java visual (como los botoncitos, listas, menús, etc) que nos permite visualizar un

árbol. En él podemos ver el típico árbol de datos en el que podemos abrir cada uno de los nodos para ver

qué tiene dentro, cerrarlos, etc. Similar al árbol de directorios que nos muestran algunas aplicaciones para

elegir un fichero.

Aunque el JTree es muy configurable, en este tutorial sólo veremos como usarlo de una forma sencilla,

usando las clases por defecto que java nos ofrece para ello.

Clases Java implicadas

Como en casi todos los componentes visuales de java, hay dos clases importantes implicadas.

Por un lado tenemos "la vista", que es la clase java que se ve. Esta clase es el JTree y es lo que se ve en la

pantalla, en nuestra ventana.

Por otro lado tenemos el "modelo de datos". Esta clase de java puede ser cualquier clase que implemente la

interface TreeModel, pero java nos ofrece ya implementada la clase DefaultTreeModel. Esta clase es la que

contiene los datos que queremos visualizar en "la vista". Contiene los datos que visualizaremos en el JTree.

¿Qué datos admite el DefaultTreeModel?. Puesto que vamos a hacer un árbol, admite datos que se puedan

asociar entre sí como padres e hijos. No valen datos cualesquiera. Esos datos deben implementar la

interface TreeNode. Cualquier clase que implemente esta interface, tendrá métodos para interrogarle sobre

quién es su padre, si tiene hijos, etc. Estos métodos será los que acabe usando JTree para saber qué debe

pintar, quién es hijo de quién y quién es padre de quién.

Existe otro tipo de dato también importante, el MutableTreeNode. Este es igual que el anterior, pero

además tiene métodos para modificar las asociaciones entre padres e hijos. Permite añadir nuevos hiijos a

los padres, cambiar el padre de los hijos y cualquier otro tipo de indecencia que se nos ocurra. Si nuestro

árbol va a cambiar sobre la marcha, nos interesa usar datos (nodos) que implementen esta interface.

Java nuevamente nos ofrece una clase que ya implementa MutableTreeNode y por tanto tiene todos los

métodos necesarios para saber quién es hijo de quién y los métodos necesarios para cambiar estas

asociaciones. Esta clase es DefaultMutableTreeNode. Tiene además un método intereseante, que es

setUserObject(). Este método nos permite guardar dentro la información que queramos. Esta información

será nuestro dato real, lo que realmente nos interesa. DefaultMutableTreeNode únicamente nos ahorrará

escribir el código necesario para mantener asociaciones entre padres e hijos, además de hacer de almacén

de nuestro dato.

Código de ejemplo

Vamos a ir haciendo código para ver cómo usar todas estas clases. Trataremos de construir y construiremos

el árbol del dibujo

Primero instanciamos nuestro modelo de datos, el DefaultTreeModel y la parte visual, el JTree. Metemos el

primero dentro del segundo.

La clase DefaultTreeModel necesita en su constructor el nodo raíz del árbol, es decir, el dato que hace de

padre de todos los demás, el de más alto nivel. Por ello, debemos instanciar este primer dato para poder

construir el DefaultTreeModel.

Ese primer dato será un DefaultMutableTreeNode. A este DefaultMutableTreeNode podemos pasarle el

dato que queramos bien a través del método que comentamos setUserObject(), bien a través del

constructor. Nuestro dato será un simple String que diga "abuelo" y lo meteremos en el constructor.

El código quedaría así

DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelo");

modelo = new DefaultTreeModel(abuelo);

JTree tree = new JTree(modelo);

En el árbol se mostrará el resultado de llamar a toString() de nuestro "user object". Como en nuestro caso es

un simple String "abuelo", el método toString() de String devuelve "abuelo" y eso es lo que se verá como raíz

del árbol.

Ahora sólo nos queda ir añadiendo el resto de los datos del árbol. Lo único que tenemos que hacer es ir

creando los nodos, como DefaultMutableTreeNode. A cada uno de ellos meterle el dato que queramos, bien

en el constructor, bien con el método setUserObject(). En nuestro caso usaremos un simple String con el

texto que queremos que se muestre. Finalmente, hay que ir asociando estos datos.

El abuelo ya lo tenemos creado, así que el código de creación de los demás nodos puede ser este

DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");

DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");

DefaultMutableTreeNode hijo=new DefaultMutableTreeNode("hijo");

DefaultMutableTreeNode hija=new DefaultMutableTreeNode("hija");

Para asociar estos datos tenemos dos opciones.

Usar los métodos add(), insert() y setParent() de DefaultMutableTreeNode para ir añadiendo unos

nodos a otros.

Usar el método insertNodeInto() de DefaultTreeModel. A este método le pasamos nodo padre e

hijo que queremos asociar y el se encarga de hacer la asociación.

La diferencia de hacerlo de una manera u otra es que JTree se entera automáticamente de cambios de

DefaultTreeModel y los refleja automáticamente en pantalla, pero no se entera de los cambios en los

DefaultMutableTreeNode y por tanto no los refresca en pantalla.

Si queremos refresco inmediato, debemos usar métodos de DefaultTreeModel. Si queremos hacer varios

cambios sin ver como se van haciendo en pantalla, podemos usar los métodos de DefaultMutableTreeNode,

pero debemos tener en cuenta que al final hay que provocar desde código el refresco del JTree, bien con un

repaint(), bien con uno de los métodos fire...() de DefaultTreeModel.

Puesto que estamos haciendo un ejemplo simple y es más simple, usaremos el método insertNodeInto()

para hacer la asociación. Este método lleva tres parámetros:

Nodo que queremos que sea hijo.

Nodo que queremos que sea padre.

En qué posición queremos que esté el hijo respecto a otros hijos. Dicho de otra forma, cuando

despleguemos un padre que tiene por ejemplo cuatro hijos, en qué posición queremos que esté

este nuevo hijo: el primero, en medio, el último...

El código para estas asociaciones es sencillo:

modelo.insertNodeInto(padre,abuelo,0);

modelo.insertNodeInto(tio, abuelo, 1);

modelo.insertNodeInto(hijo, padre, 0);

modelo.insertNodeInto(hija, padre, 1);

Ya está. Esto construye el árbol de la figura inicial. En PruebaJTree.java puedes ver el ejemplo completo.

El siguiente paso es cambiar esos iconos tan feos que salen en el árbol por otros más horribles, pero que al

menos sean de nuestra propia cosecha.

Cambiar los iconos de JTree

Ahora que ya sabemos cómo construir un JTree en java, vamos a avanzar un pequeño paso más. Vamos a

cambiar los iconos de que salen en el JTree de una forma sencilla.

Coneptos básicos: el TreeCellRenderer y el DefaultTreeCellRenderer

Cuando un JTree necesita pintar un dato, le pregunta a otra clase cómo se dibuja ese dato. Esa otra clase,

que si no hacemos nada para remediarlo está dentro del JTree y no la vemos, se llama

DefaultTreeCellRenderer. La responsabilidad de esta clase es saber cómo se dibujan los datos en el árbol y

entre otras cosas, saber también qué icono se debe poner a cada dato, en función de que sea un nodo

abierto, un nodo cerrado o un nodo final (hoja).

Al JTree en realidad le vale cualquier clase que tenga un método al que él le pase el dato y la clase le

devuelva cómo dibujarlo. Para asegurar que existe ese método, está la interface TreeCellRenderer. La clase

DefaultTreeCellRenderer implementa esa interface y nosotros podríamos hacernos nuestras propias clases

que implementen esa interface.

El JTree, en su método getCellRenderer() nos devuelve la clase que está usando para saber cómo dibujar los

datos. Con su método setCellRenderer() podríamos pasarle una clase hecha a nuestra medida.

En resumen, JTree para saber cómo pintar los datos utilza una clase que implemente TreeCellRenderer. Si

nadie le da una clase que implemente esta interface, JTree se construye un DefaultTreeCellRenderer.

Cambiar los iconos con DefaultTreeCellRenderer

Si sólo queremos cambiar los iconos, no es necesario construirnos una clase completa que implemente

TreeCellRenderer. Podemos aprovechar la clase DefaultTreeCellRenderer que el JTree ya tiene dentro.

Lo primero que debemos hacer, es pedírsela al JTree

DefaultTreeCellRenderer render= (DefaultTreeCellRenderer)tree.getCellRenderer();

JTree nos devuelve un TreeCellRenderer, pero nosotros sabemos que en realidad es un

DefaultTreeCellRenderer. Por eso hacemos el "cast", esa cosa entre paréntesis.

Una vez que lo tenemos, sólo hay que cambiar los iconos, usando los métodos que tiene la clase

DefaultTreeCellRenderer:

setLeafIcon() para cambiar el icono de los nodos hoja (nodos sin hijos).

setOpenIcon() para cambiar el icono de los nodos con hijos que están desplegados (sus hijos son

visibles).

setClosedIcon() para cambiar el icono de los nodos con hijos que están cerrados (los hijos no son

visibles).

El código, cogiendo unos iconos ficiticios que están en la unidad D:\, podría ser como este

ender.setLeafIcon(new ImageIcon("d:/futbol.gif"));

render.setOpenIcon(new ImageIcon("d:/hombre.gif"));

render.setClosedIcon(new ImageIcon("d:/viejo.gif"));

Y esto nos daría un árbol como el de la foto

en el que hemos puesto a un viejecito para el nodo "padre" que tiene hijos, pero no se ven. Un señor para el

nodo "abuelo", que tiene hijos visibles. Y un niño jugando al futbol para el nodo "tio", que no tiene hijos.

Aquí puedes ver el código completo PruebaJTree2.java.

El siguiente paso es complicarnos más la vida y cambiar totalmente el aspecto del JTree.

Crear una barra de herramientas en Java

In this section, you will learn how to create toolbar in java. En esta sección, usted aprenderá cómo crear barra de herramientas de Java. Swing provides a most important feature for creating an interactive

component. Swing proporciona una importante característica más para la creación de un componente interactivo. Toolbar is a area which is situated inside the main window of any applications on top. Toolbar es una zona que se encuentra dentro de la ventana principal de todas las aplicaciones en la parte superior. Tool Bar contains multiple command buttons for shortcuts. Barra de herramientas contiene botones de comando para múltiples accesos directos. The toolbar has been arranged horizontal in this program but, if you want to

make it vertically, you can do so. La barra de herramientas se ha dispuesto horizontal en este programa, pero, si quieres hacerlo verticalmente, puede hacerlo. Pictorial representation is given below: La

representación pictórica es la siguiente:

Here, you will see a simple toolbar, Which have three command buttons like: cut, copy and paste with small images. Aquí, usted verá una barra de herramientas simples, que tienen tres botones de comando como:

cortar, copiar y pegar con imágenes pequeñas. For showing these three buttons on the toolbar of the frame various APIs as follows have been used: Para muestra estos tres botones en la barra de herramientas de las

diferentes APIs marco de la siguiente se han utilizado:

JToolBar(): JToolBar (): This is the constructor of the JTooBar class which has been used to create a new toolbar. Este es el

constructor de la clase JTooBar que se ha utilizado para crear una nueva barra de herramientas.

JToolBar.HORIZONTAL JToolBar.HORIZONTAL This is the constant field of the JToolBar class which support to situating the Tool Bar horizontal on the

frame. Este es el campo de la constante de la clase JToolBar que apoyan a situar la barra de herramientas horizontales en el marco.

Here is the code of program: Aquí está el código del programa: import javax.swing.*; import java.awt.*;

public class CreateToolbar { public static void main ( String [] args ) { JFrame frame = new JFrame ( "Create a toolbar Which have three buttons Such as: Cut, Copy, Paste" ) ; JToolBar toolbar = new JToolBar ( "Toolbar" , JToolBar.HORIZONTAL ) ; JButton cutbutton = new JButton ( new ImageIcon ( "cut.gif" )) ; toolbar.add ( cutbutton ) ; JButton copybutton = new JButton ( new ImageIcon ( "copy.gif" )) ; toolbar.add ( copybutton ) ; JButton pastebutton = new JButton ( new ImageIcon ( "paste.gif" )) ; toolbar.add ( pastebutton ) ; frame.getContentPane () .add ( toolbar,BorderLayout.NORTH ) ; frame.setUndecorated ( true ) ; frame.getRootPane () .setWindowDecorationStyle ( JRootPane.PLAIN_DIALOG ) ;

frame.setDefaultCloseOperation ( JFrame.EXIT_ON_CLOSE ) ; frame.setSize ( 500 , 400 ) ; frame.setVisible ( true ) ; } }

Agregar iconos a JTextPane

JEDITORPANE

Dos clases de Swing apoyo texto con estilo: JEditorPane y su subclase JTextPane . El JEditorPane clase es la base para el texto de los componentes de estilo de swing y proporciona un mecanismo mediante el cual se puede añadir soporte para los formatos de texto personalizado uno. Si sin estilo desea que el texto, uso de área de texto en lugar .

You can see an editor pane and a text pane in use by running TextSamplerDemo. Here is a picture of the example. Se puede ver un panel de editor y un panel de texto en uso mediante la ejecución de TextSamplerDemo. Aquí está una foto de la TextSamplerDemo ejemplo.

Click the Launch button to run TextSamplerDemo using ( ). Alternatively, to compile and run the example yourself, consult the .

import java.awt.BorderLayout;

import javax.swing.Icon; import javax.swing.ImageIcon; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JScrollPane; import javax.swing.JTextPane; import javax.swing.text.BadLocationException; import javax.swing.text.DefaultStyledDocument; import javax.swing.text.Style; import javax.swing.text.StyleConstants; import javax.swing.text.StyleContext; import javax.swing.text.StyledDocument;

public class JTextPaneWithIcon { public static void main ( String args []) { JFrame frame = new JFrame ( "TextPane Example" ) ; frame.setDefaultCloseOperation ( JFrame.EXIT_ON_CLOSE ) ;

StyleContext context = new StyleContext () ; StyledDocument document = new DefaultStyledDocument ( context ) ;

Style labelStyle = context.getStyle ( StyleContext.DEFAULT_STYLE ) ;

Icon icon = new ImageIcon ( "yourFile.gif" ) ; JLabel label = new JLabel ( icon ) ; StyleConstants.setComponent ( labelStyle, label ) ;

try { document.insertString ( document.getLength () , "Ignored" , labelStyle ) ;

} catch ( BadLocationException badLocationException ) { System.err.println ( "Oops" ) ; } JTextPane textPane = new JTextPane ( document ) ; textPane.setEditable ( false ) ; JScrollPane scrollPane = new JScrollPane ( textPane ) ; frame.add ( scrollPane, BorderLayout.CENTER ) ;

frame.setSize ( 300 , 150 ) ; frame.setVisible ( true ) ; } }

Ejemplo de JEditorPane y JTextPane

En java tenemos varios componentes visuales que nos permiten escribir texto o pedírselo al usuario. Cada

uno de estos componentes es adecuado para una cosa. Vamos a ver cuales son y veremos un ejemplo de los

dos más complicados y completos.

Los componentes de texto son:

JTextField: Un campo de texto que permite pedir/mostrar una sola línea de texto. No admite

mezclar fuentes de texto, colores ni nada parecido. Es adecuado para pedir, por ejemplo, un

nombre, un teléfono, etc.

JFormattedTextField. Como el anterior, pero más avanzado. Permite pedir datos, de una sola línea,

que cumplan unas ciertas restricciones o un cierto formato. Es adecuado para pedir fechas, horas,

direcciones IP, etc. Incluso para pedir datos numéricos si queremos controlar que no se puedan

escribir letras.

JPasswordField: Este sirve para pedir una password. Sólo pinta asteriscos.

JTextArea. Este ya admite varias líneas de texto, pero es un editor simple. No admite mezclar

fuentes de letra, cursivas, imágenes, etc. Todo el texto, en varias líneas, pero con una única fuente

de letra.

JEditorPane. Este es más complejo que el anterior y admite texto con cierto formato. Admite texto

plano, HTML y RTF por defecto, aunque podríamos ampliarlo. Este sí permite mezclar fuentes,

colores e imágenes.

JTextPane. Este es el más complejo de todos. Admite lo mismo que el anterior, pero además

permite que vayamos añadiendo texto cada uno con sus propios atributos de texto -fuentes,

colores, etc-. Admite también directamente iconos de la clase Icon de java e incluso cualquier

Component de java, como JButton, etc.

Vamos a ver aquí un ejemplo de los dos últimos. Del JEditorPane y del JTextPane.

Ejemplo de JEditorPane

Como ya hemos comentado, el JEditorPane admite texto con cierto formato. Por defecto conoce el texto

plano, el HTML y el RTF, aunque debemos decirle a priori qué es lo que va a usar.

JEditorPane editor = new JEditorPane();

...

// Marcamos el editor para que use HTML

editor.setContentType("text/html");

...

// o para que use RTF

editor.setContentType("text/rtf");

...

// o para texto normalito

editor.setContentType("text/plain");

El tipo de texto normalito "text/plain" es el de defecto, así que si no indicamos nada, es el que se usará.

Si queremos construir otros formatos, debemos heredar de javax.swing.text.EditorKit y construirnos una

clase definiendo todos los métodos abstractos. Sin embargo eso es mucho para este tutorial, así que

simplemente saber que existe esa posibilidad.

Para los formatos que java entiende, java nos proporciona clases que heredan de EditorKit y saben tratar los

tipos de texto mencionados, pero el JEditorPane las maneja internamente y no nos enteraremos de su

existencia, pero que sepas que son DefaultEditorKit, HTMLEditorKit y RTFEditorKit.

Ejemplo de JEditorPane con HTML

Vamos con el caso de HTML. Una vez configurado nuestro editor, simplemente tenemos que meterle un

texto HTML con setText(), así

// Marcamos el editor para que use HTML

editor.setContentType("text/html");

// Insertamos un texto

editor.setText(

"<b>hola</b><br>" + "<i>adios</i><br>" +

"<font face=\"arial\">fuente arial</font><br>" +

"<font face=\"courier\">fuente courier</font><br>" +

"<font size=\"24\">fuente grande</font><br>" +

"<font color=\"red\">color rojo</font><br>" +

"<img src=\"file:d:/viejo.gif\"></img>");

Como ves, no me he preocupado de poner los tags <html>, <head> ni <body>, aunque se debería. De todas

formas, funciona bien.

En ese texto hay negritas, cambios de fuente de letra, tamaño, color e incluso una imagen. Fijate que he

tenido que "escapar" las comillas, poniendo un \ delante, para distinguirlas de las comillas de principio y fin

del texto java. La imagen la he puesto con path absoluto y de fichero, aunque se puede poner también una

imagen remota con http://dominio.com/path/unaImagen.gif o lo que se quiera. De hecho, el método

setPage() de esta clase admite una URL y es capaz de leer una página completa a través de internet.

JEditorPane no tiene métodos para ir añadiendo más texto, así que a través de setText() debemos dar todo

el texto del golpe. Si queremos hacer modificaciones -añadir más texto, borrar, modificar-, debemos pedir el

Document con el método getDocument() y trabajar con él, aunque no es trivial.

Si para la imagen quieres usar path relativos, debes ser más cuidadoso, puesto que ... ¿relativos a qué

directorio?. Para usar path relativos, tienes que indicar el tab <base> en el <head> del HTML. Sería esto más

o menos

// Insertamos un texto

editor.setText(

"<head><base href=\"file:d:/\"></head>"+

"<b>hola</b><br>" + "<i>adios</i><br>" +

"<font face=\"arial\">fuente arial</font><br>" +

"<font face=\"courier\">fuente courier</font><br>" +

"<font size=\"24\">fuente grande</font><br>" +

"<font color=\"red\">color rojo</font><br>" +

"<img src=\"viejo.gif\"></img>");

La ventana al ejecutar esto sería

y el código completo es EjemploJEditorPaneHtml.java.

Ejemplo de JEditorPane con RTF

Para RTF es exactamente igual, pero cambian los datos. Esta sería la forma

// Se le dice al editor que va a usar RTF

editor.setContentType("text/rtf");

// Un texto en RTF

editor.setText(

"{\\rtf1" +

"{\\colortbl ;\\red255\\green0\\blue0;}" +

"Esto\\par " +

"es una \\b prueba\\b0 de \\i cursiva\\i0\\par " +

"y \\cf1 todo\\cf0 \\par" + "}");

Bueno, el texto en formato RTF es un poco raro para los que, como yo, no estamos acostumbrados a él. Usa

muchas \ que hemos tenido que "escapar" poniendo \\ para que el compilador de java no las interprete -

mejor dicho, interprete \\ como \-.

Simplemente comenzamos el texto con un {\rtf1, definimos una tabla de colores con un solo color RGB rojo,

ponemos un par de párrafos con negrita \b y cursiva \i y luego un todo de color rojo con \cf1 y \cf0. No voy a

explicar aquí más detalles de RTF, pero si tienes interés no te costará encontrar algo por internet.

El caso es que mostrando este editor, tenemos la siguiente foto

y el código java para mostrar esta ventana es EjemploJEditorPaneRtf.java.

Ejemplo de JTextPane.

JTextPane es otro editor que admite colores, fuentes, tamaños, etc. Admite incluso que el pongamos

directamente iconos pasándole una clase Icon de java o que le añadamos Component de java, como JButton,

JLabel, etc.

Para añadir texto, debemos ir añadiéndolo indicando en cada caso que "atributos" queremos para ese texto.

Si lo queremos en negrita, con tal fuente de letra, tamaño, tal color, etc.

Sin embargo, estos componentes JEditorPane y JTextPane no tienen métodos para ir añadiendo poco a poco

el texto. Simplemente tienen un método setText() al que se pasa todo el texto de golpe. Para poder trabajar

con el JTextPane, debemos pedirle el Document asociado con getDocument() y trabajar con él, que sí tiene

métodos para ir añadiendo texto poco a poco.

Por ejemplo, para añadir un trozo de texto en negrita, haríamos esto

// Se instancia el JTextPane

JTextPane editor = new JTextPane();

// Atributos para la frase, en negrita

SimpleAttributeSet attrs = new SimpleAttributeSet();

StyleConstants.setBold(attrs, true);

// Se inserta

editor.getStyledDocument().insertString(

editor.getStyledDocument().getLength(), "Negrita", attrs);

La parte de instanciar el editor no debería presentar ningún problema.

Luego hemos instanciado una clase SimpleAttributeSet. Esta clase es la que guardará los atributos para un

determinado texto: si es negrita, cursiva, fuente, etc. Para modificar el valor de estos atributos, nos ayuda la

clase StyleConstants. Esta clase tiene muchos métodos para cambiar valores a una clase SimpleAttributeSet.

En este caso concreto hemos usado setBold() para ponerlo en negrita.

StyleConstants.setBold(attrs, true);

Luego, simplemente, hemos insertado el texto. Pero esto requiere una pequeña explicación.

Primero obtenemos el StyledDocument, que es lo que el JTextPane tiene dentro y representa al texto que

estamos viendo.

editor.getStyledDocument()

El StyledDocument tiene un método insert() que admite tres parámetros:

Posición en la que se quiere insetar el texto dentro del documento.

El texto

Los atributos del texto.

Como queremos insertar al final, la posición es justo la longitud del texto. Eso se obtiene con el método

getLength() así

editor.getStyledDocument().getLength()

Los otros dos parámetros son simplemente el texto "Negrita" y los atributos que fijamos antes.

Insertar icono en JTextPane

También podemos insertar un icono. El método para ello es insertIcon(). Este método reemplaza lo que hay

seleccioado en el JTextPane por el icono. Si sólo queremos insertarlo al final, debemos cambiar la selección

del texto al final, sin seleccionar nada. Eso se hace con el método setCaretPosition().

El trozo de código para insertar un icono al final sería

// Ponemos el cursor de seleccion al final del texto

editor.setCaretPosition(editor.getStyledDocument().getLength());

// Un icono

ImageIcon icono = new ImageIcon("d:/viejo.gif");

editor.insertIcon(icono);

Obtenemos la longitud del texto de la misma forma que antes. Usamos esa longitud para llevar allí la

selección con el método setCaretPosition().

Luego, simplemente cargar el icono y añadirlo.

Insertar un Component en JTextPane

También podemos añadir un Component cualquiera. Por ejemplo, un JButton. El método es

insertComponent() y, al igual que en el caso anterior, reemplaza el texto que haya seleccionado por el

Component. Al igual que antes, con setCaretPosition() nos vamos al final del texto e insertamos el JButton.

// Ponemos el cursor al final del texto

editor.setCaretPosition(editor.getStyledDocument().getLength());

// insertamos un JButton

JButton boton = new JButton("Pulsame");

editor.insertComponent(boton);

Con todo esto y alguna cosa más, obtenemos el editor de la figura

y el código para obtener eso es EjemploJTextPane.java.

Una de las tareas que puede realizar sin saber nada sobre el sistema de texto Swing es mostrar el texto de una URL. Este es el código de TextSamplerDemo.java que crea un panel del editor de texto editable que muestra el formato con etiquetas HTMLJEditorPane editorPane = new JEditorPane();editorPane.setEditable(false);java.net.URL helpURL = TextSamplerDemo.class.getResource( "TextSamplerDemoHelp.html");if (helpURL != null) { try { editorPane.setPage(helpURL); } catch (IOException e) { System.err.println("Attempted to read a bad URL: " + helpURL); }} else { System.err.println("Couldn't find file: TextSamplerDemoHelp.html");}

//Put the editor pane in a scroll pane.JScrollPane editorScrollPane = new JScrollPane(editorPane);editorScrollPane.setVerticalScrollBarPolicy( JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);editorScrollPane.setPreferredSize(new Dimension(250, 145));editorScrollPane.setMinimumSize(new Dimension(10, 10));

Un ejemplo del uso de un panel de texto

Here is the code from the example that creates and initializes a text pane. Aquí está el código de la TextSamplerDemo ejemplo que crea e inicializa un panel de texto.

String[] initString =String[] initString ={ /* ... fill array with initial text ... */ };

String[] initStyles ={ /* ... fill array with names of styles ... */ };

JTextPane textPane = new JTextPane();

StyledDocument doc = textPane.getStyledDocument();addStylesToDocument(doc);

//Load the text pane with styled text.try { for (int i=0; i < initString.length; i++) {

doc.insertString(doc.getLength(), initString[i], doc.getStyle(initStyles[i]));

}} catch (BadLocationException ble) { System.err.println("Couldn't insert initial text into text pane.");}

JSLIDER Se utiliza un JSLIDER para permitir que el usuario introduzca un valor numérico limitado por una valor máximo y un valor mínimo. Mediante la utilización de un Slider en vez de text field, se eliminan errores de entrada. Fichero: DemoSlider.java1 // Uso de objetos JSlider para ajustar el tamaño de un óvalo.2 import java.awt.*;3 import java.awt.event.*;4 import javax.swing.*;5 import javax.swing.event.*;6 7 public class DemoSlider extends JFrame {8 private JSlider sliderDiametro;9 private PanelOvalo miPanel;10 11 // configurar GUI12 public DemoSlider() 13 {14 super( "Demostración de JSlider" );15 16 // establecer PanelOvalo17 miPanel = new PanelOvalo();18 miPanel.setBackground( Color.YELLOW );19 20 // establecer objeto JSlider para controlar el valor del diámetro21 sliderDiametro = 22 new JSlider( SwingConstants.HORIZONTAL, 0, 200, 10 );23 sliderDiametro.setMajorTickSpacing( 10 );24 sliderDiametro.setPaintTicks( true );25 26 // registrar componente de escucha de eventos de JSlider27 sliderDiametro.addChangeListener(28 29 new ChangeListener() { // clase interna anónima30 31 // manejar cambio en el valor del control deslizable32 public void stateChanged( ChangeEvent e )33 {34 miPanel.establecerDiametro( sliderDiametro.getValue() );35 }

36 37 } // fin de la clase interna anónima38 39 ); // fin de la llamada a addChangeListener40 41 // adjuntar componentes al panel de contenido42 Container contenedor = getContentPane();43 contenedor.add( sliderDiametro, BorderLayout.SOUTH );44 contenedor.add( miPanel, BorderLayout.CENTER );45 46 setSize( 220, 270 );47 setVisible( true );48 49 } // fin del constructor de DemoSlider50 51 public static void main( String args[] )52 {53 DemoSlider aplicacion = new DemoSlider();54 aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );55 }56 57 } // fin de la clase DemoSlider

Fichero: PanelOvalo.java// Una clase JPanel personalizada.2 import java.awt.*;3 import javax.swing.*;4 5 public class PanelOvalo extends JPanel {6 private int diametro = 10;7 8 // dibujar un óvalo del diámetro especificado9 public void paintComponent( Graphics g )10 {11 super.paintComponent( g );12 13 g.fillOval( 10, 10, diametro, diametro );14 }15 16 // validar y establecer el diámetro, después repintar 17 public void establecerDiametro( int nuevoDiametro )18 {19 // si el diámetro es inválido, usar valor predeterminado de 1020 diametro = ( nuevoDiametro >= 0 ? nuevoDiametro : 10 );21 repaint();22 }23 24 // utilizado por el administrador de esquemas para determinar el tamaño preferido25 public Dimension getPreferredSize()26 {27 return new Dimension( 200, 200 );28 }29

30 // utilizado por el administrador de esquemas para determinar el tamaño mínimo31 public Dimension getMinimumSize()32 {33 return getPreferredSize();34 }35 36 } // fin de la clase PanelOvalo

JTOGGLEBUTTONImplementa la funcionalidad de alternar heredado por JCheckBox y JRadioButton . Puede ser una instancia o una subclase para crear dos botones de estado.

JToggleButton Demo

import java.awt.BorderLayout;import java.awt.Container;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.ItemEvent;import java.awt.event.ItemListener;import javax.swing.AbstractButton;import javax.swing.ButtonModel;import javax.swing.JFrame;import javax.swing.JToggleButton;import javax.swing.event.ChangeEvent;import javax.swing.event.ChangeListener;public class SelectingToggle { public static void main(String args[]) { String title = (args.length == 0 ? "Selecting Toggle" : args[0]); JFrame frame = new JFrame(title); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JToggleButton toggleButton = new JToggleButton("Selected"); ActionListener actionListener = new ActionListener() { public void actionPerformed(ActionEvent actionEvent) { AbstractButton abstractButton = (AbstractButton) actionEvent.getSource(); boolean selected = abstractButton.getModel().isSelected(); System.out.println("Action - selected=" + selected + "\n"); } }; ChangeListener changeListener = new ChangeListener() { public void stateChanged(ChangeEvent changeEvent) { AbstractButton abstractButton = (AbstractButton) changeEvent .getSource();

ButtonModel buttonModel = abstractButton.getModel(); boolean armed = buttonModel.isArmed(); boolean pressed = buttonModel.isPressed(); boolean selected = buttonModel.isSelected(); System.out.println("Changed: " + armed + "/" + pressed + "/" + selected); } }; ItemListener itemListener = new ItemListener() { public void itemStateChanged(ItemEvent itemEvent) { int state = itemEvent.getStateChange(); if (state == ItemEvent.SELECTED) { System.out.println("Selected"); } else { System.out.println("Deselected"); } } }; // Attach Listeners toggleButton.addActionListener(actionListener); toggleButton.addChangeListener(changeListener); toggleButton.addItemListener(itemListener); Container contentPane = frame.getContentPane(); contentPane.add(toggleButton, BorderLayout.NORTH); JToggleButton toggleButton2 = new JToggleButton("Focused"); contentPane.add(toggleButton2, BorderLayout.CENTER); JToggleButton toggleButton3 = new JToggleButton("Not Selected"); contentPane.add(toggleButton3, BorderLayout.SOUTH); frame.setSize(300, 125); frame.setVisible(true); }}

JTABLE

Un JTABLE es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc

El cuadro del SimpleTableDemo.java declara los nombres de columna en una matriz de String:

String[] columnNames = {"First Name", "Last Name", "Sport", "# of Years", "Vegetarian"};Sus datos se inicializa y se almacena en una matriz de objetos de dos dimensiones:

Object[][] data = { {"Kathy", "Smith", "Snowboarding", new Integer(5), new Boolean(false)}, {"John", "Doe",

"Rowing", new Integer(3), new Boolean(true)}, {"Sue", "Black", "Knitting", new Integer(2), new Boolean(false)}, {"Jane", "White", "Speed reading", new Integer(20), new Boolean(true)}, {"Joe", "Brown", "Pool", new Integer(10), new Boolean(false)}};

A continuación, la tabla se construye con estos datos y columnNames:

JTable table = new JTable(data, columnNames);

Hay dos JTable constructores que aceptan directamente los datos ( SimpleTableDemo utiliza la primera):

JTable(Object[][] rowData, Object[] columnNames)

JTable(Vector rowData, Vector columnNames)

Agregar una tabla a un contenedor

Here is typical code for creating a that serves as a container for a table: Aquí está el código típico para la creación de un panel de desplazamiento que sirve como contenedor de una tabla

JScrollPane scrollPane = new JScrollPane(table);table.setFillsViewportHeight(true);

Las dos líneas en este fragmento de hacer lo siguiente:

El JScrollPane constructor se invoca con un argumento que se refiere al objeto de tabla. Esto crea un panel de desplazamiento como un contenedor para la tabla, la tabla se añade automáticamente al contenedor.

JTable.setFillsViewportHeight se invoca para fijar el fillsViewportHeight propiedad. Cuando esta propiedad es true la tabla utiliza toda la altura del envase, incluso si la tabla no tiene filas suficiente para usar todo el espacio vertical. Esto hace que sea más fácil utilizar la tabla como una-y-soltar destino de arrastre.

El panel de desplazamiento coloca automáticamente el encabezado de la tabla en la parte superior de la ventana gráfica. Los nombres de columnas permanecen visibles en la parte superior del área de visualización cuando la tabla de datos se desplaza.

Si está utilizando una tabla sin un panel de desplazamiento, debe obtener el componente de cabecera de la tabla y el lugar por sí mismo. Por ejemplo:

Si está utilizando una tabla sin un panel de desplazamiento, debe obtener el componente de cabecera de la tabla y el lugar por sí mismo. For example: Por ejemplo:

container.setLayout(new BorderLayout());

container.add(table.getTableHeader(), BorderLayout.PAGE_START);container.add(table, BorderLayout.CENTER);

Iconos y colores en un JTabbedPane

De ChuWiki

Saltar a navegación, buscar

En este ejemplo haremos un JTabbedPane y le pondremos en las pestañas unos iconos y unos colores de fondo.

Para los iconos basta llamar al método setIconAt(), indicando la pestaña y el Icon que queremos poner.

Para el color de fondo de la pestaña, basta llamar al método setBackgroundAt(), indicando la pestaña y el color de fondo que queremos poner.

Aquí tienes un ejemplo completo en el que se visualiza un JFrame con un JTabbedPane dentro con cuatro pestañas. Cada uno con su icono y su color chillón. Tú trabajo consiste en elegir una selección de colores más agradable.

package com.chuidiang.ejemplos.iconos_component;

import java.awt.Color;

import javax.swing.ImageIcon;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JTabbedPane;import javax.swing.WindowConstants;

/** * Ejemplo de Iconos y colores de fondo en las pestañas de un JTabbedPane * @author chuidiang * */public class IconosJTabbedPane { /** * Crea un JFrame con un JTabbedPane dentro. A cada pestaña del * JTabbedPane le pone un icono y un color * @param args */ public static void main(String[] args) { // La ventana principal JFrame v = new JFrame("Ejemplo Iconos JTabbedPane");

// El JTabbedPane con sus pestañas e iconos en las mismas. JTabbedPane tp = new JTabbedPane(); tp.add("uno", new JLabel("En la pestaña uno")); tp.add("dos", new JLabel("En la pestaña dos")); tp.add("tres", new JLabel("En la pestaña tres"));

tp.add("cuatro", new JLabel("En la pestaña cuatro")); // Los iconos tp.setIconAt(0, new ImageIcon("kopete010.gif")); tp.setIconAt(1, new ImageIcon("kopete011.gif")); tp.setIconAt(2, new ImageIcon("kopete012.gif")); tp.setIconAt(3, new ImageIcon("kopete013.gif")); // Los colores de fondo tp.setBackgroundAt(0, Color.yellow); tp.setBackgroundAt(1, Color.red); tp.setBackgroundAt(2, Color.green); tp.setBackgroundAt(3, Color.blue);

// Se visualiza todo v.getContentPane().add(tp); v.setSize(500,300); v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); v.setVisible(true); }}

y este es el resultado de ejecutar el programa

package jframe;

import java.awt.BorderLayout;import java.awt.Color;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JTabbedPane;

/** * * @author Familia Bolaños */public class Jpanel {

//declaracion, creacion e inicializacion de componentes, objetos y variables

static JFrame ventana = new JFrame();

static JTabbedPane folders = new JTabbedPane();

static JPanel panel1 = new JPanel();

static JLabel jl1= new JLabel("label1");static JLabel jl2= new JLabel("label2");

static JLabel jl3= new JLabel("label3");static JLabel jl4= new JLabel("label4");

static JLabel jl5= new JLabel("label5");static JLabel jl6= new JLabel("label6");

static JButton b1 = new JButton("Hola");

// parte principal de programa

public static void main(String[] args)

{ // area de definicion de propiedades de el objeto

ventana.setTitle("mi programa"); ventana.setBounds(50,50,500,500);ventana.setLayout(null);

ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

b1.setBounds(40,40,100,20);folders.setBounds(30,30,300,300);

//cargando panel con sus componentes

panel1.add(b1);panel1.setLayout(null);folders.add(jl1);folders.add("Panel",panel1);

//cargando tabbedpane con un componente y titulo = componente

ventana.add(folders);ventana.setVisible(true);

//area de asociacion de objeto-eventos

}; // termina main

} //

Ejemplo de JLayeredPane para imagen de fondoDe ChuWiki

Saltar a navegación, buscar

El JLayeredPane es un contenedor java que admite otros componentes. La particularidad que tiene es que sitúa estos componentes en capas, de forma que se superponen unos sobre otros. Podemos aprovechar esta característica para dibujar nuestros componentes sobre una imagen de fondo. Para ello, haremos dos capas. Una capa de fondo con un JLabel con la

imagen que queremos mostrar y otra capa superior con nuestro panel con los componentes. Para nuestro ejemplo, usaremos como panel un simple JLabel con una etiqueta.

El JLayeredPane no lleva ningún tipo de layout, por lo que deberemos ponerl tamaño a los componentes con un setSize().

Cuando añadimos un componente al JLayeredPane, podemos usar el método add(Component, Object), de forma que el Component sea el componente que queremos añadir y Object sea un Integer. Cuanto más alto sea el Integer, más arriba estará el componente y tapará a los componentes cuyo Integer sea más bajo.

A continuación un ejemplo completo que muestra el JLabel con la imagen de fondo y un JLabel superpuesto encima. Por supuesto, tendrás que cambiar el nombre de la imagen por una que tengas tú.

package com.chuidiang.ejemplos.layered_pane;

import javax.swing.ImageIcon;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JLayeredPane;import javax.swing.WindowConstants;

/** * Ejemplo de JLayeredPane con una imagen de fondo. * * @author Chuidiang * */public class EjemploJLayeredPane {

/** * Crea una ventana con un JLayeredPane, le pone una imagen de

fondo y una * etiqueta encima. * * @param args */public static void main(String[] args) {

// La ventana y el layered pane.JFrame v = new JFrame("Ejemplo de JLayeredPane");JLayeredPane layered = new JLayeredPane();

// La imagen de fondo metida en un JLabel, dandole el// tamano adecuado.JLabel fondo = new JLabel();ImageIcon imagen = new ImageIcon("asics-gel.gif");fondo.setIcon(imagen);fondo.setSize(imagen.getIconWidth(),

imagen.getIconHeight());

// La etiqueta que ira encima de la imagen.JLabel primerPlano = new JLabel("Primer plano");

primerPlano.setSize(200, 40);

// Se mete imagen y etiqueta en el JLayeredPane.// Debe ser Integer, no vale int.// Los Integer bajos corresponden a capas del fondo.layered.add(fondo, new Integer(1));layered.add(primerPlano, new Integer(2));

// Se visualiza todo.v.getContentPane().add(layered);v.setSize(imagen.getIconWidth(), imagen.getIconHeight());v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);v.setVisible(true);

}

}

ARCHIVOS EN JAVA

try {    FileWriter fw = new FileWriter("archivoplano.txt");    BufferedWriter bw = new BufferedWriter(fw);    PrintWriter salida = new PrintWriter(bw);    salida.println("esto escribe una linea en el archivo");    salida.close();}catch(java.io.IOException ioex) {  System.out.println("se presento el error: "+ioex.toString());}

para leerlo :Código:

try {  String texto="";                FileReader fr = new FileReader("archivoplano.txt");  entrada = new BufferedReader(fr);  String s;  while((s = entrada.readLine()) != null)texto += s + "  \n";}catch(java.io.FileNotFoundException fnfex) {  System.out.println("se presento el error: "+fnfex.toString());}