Ejemplos java y C/linux Twittear

Editar nodos de un JTree

Ya hemos cambiado totalmente el aspecto de nuestro JTree. Vamos ahora a ver cosas sobre cómo editar los nodos.

El JTree por defecto no es editable, no podemos modificar el contenido de los nodos de un árbol desde el mismo JTree. Cambiar este comportamiento es fácil, basta llamar al método setEditable(true) del JTree para hacer que los nodos sean editables.

tree.setEditable(true);

Para editar un nodo, hay dos posibilidades según la API:

• Hacer un triple click sobre el nodo. El doble click es el que expande y contrae nodos, así que han decidido usar el triple click.
• El siguiente ritual: hacer click en el nodo. Esperar. Hacer otro click y esperar creo que dos segundos. ¡et voile!, el nodo se edita.

Sin embargo, el editor por defecto que pone el JTree tiene una pequeña pega. Convierte nuestro dato a String usando toString(), lo mete en un JTextField y recoge el valor editado del JTextField como String. Si editamos de la forma por defecto, nuestros datos se transformarán en String. Si metes un Integer en el "user object" del DefaultMutableTreeNode (ver ejemplo sencillo de JTree) y lo editas, se convetirá en un String, con un valor numérico dentro, pero String. Si el dato es una clase propia nuestra, que no conoce java, no te digo qué puede pasar y en qué queda convertido.

Vamos a ver en este tutorial cómo cambiar ese editor por defecto, de forma que podamos hacerlo como queramos y podamos editar cualquier tipo de dato que necesitemos, incluidos nuestras propias clases. Por supuesto, debermos hacer un editor específico para cada tipo de dato que queramos editar.

Conceptos básicos de edición en el JTree

Veamos cómo es el proceso de edición. El JTree no tiene ni idea de cómo se edita un nodo, así que le pregunta a otra clase que tiene dentro sobre todo lo relacionado con este tema. Esta clase es el DefaultTreeCellEditor. En realidad le vale cualquier clase que implemente la interface TreeCellEditor, pero si no le pasamos una clase desde fuera que implemente esta interface, JTree usará el DefaultTreeCellEditor.

Cada vez que el usuario Federico Ratón hace algo sobre un nodo (un click, doble click o lo que sea), el JTree le pregunta al TreeCellEditor si se debe comenzar o no la edición, a través del método treeCellEditor.isCellEditable(). Si este método devuelve false, no pasa nada, si devuelve true, comienza la edición.

Si comienza la edición, JTree le pide al TreeCellEditor el Component que hará las veces de editor. Esto lo hace por medio del método treeCellEditor.getTreeCellEditorComponent(). Entre otros parámetros, a este método el JTree le pasa el valor del nodo que se quiere editar. El método crea un Component que haga de editor (por ejemplo, un JTextField) y mete dentro de ese Component el valor que se quiere editar. Devuelve entonces el Component (el JTextField) y JTree se lo presenta a Federico Ratón en la pantalla, para que juegue a sus anchas con el ratón y el teclado.

Como este Component que hace de editor puede ser cualquier cosa que nos inventemos, desde un JTextField hasta un JPanelSuperComplicadoConMilPuñetasDentroYVentanasDesplegables, el JTree se ve incapaz de enterarse él solo cuándo termina la edición. El JTree le pide al TreeCellRenderer que le avise cuando termine la edición. Para eso, llama al método treeCellRender.addCellEditorListener(), pasándole una clase (un CellEditorListener) a la que se debe avisar cuando termine la edición. El TreeCellRenderer debe guardarse esa clase y además debe estar pendiente de su Component que hace de editor. Si Federico Ratón pulsa la tecla de escape (o cualquier otro mecanismo que decidamos para cancelar la edición), el TreeCellRenderer debe avisar al CellEditorListener de que la edición se ha cancelado. Si Federico Ratón mete un montón de datos y pulsa el botón de "Aceptar", o la tecla <intro> o cualquier otro mecanismo que ideemos para validar la entrada, el TreeCellRenderer debe avisar al CellEditorListener que la edición se ha terminado y tenemos un nuevo valor disponible para el nodo.

Cuando el JTree se entera que hay un nuevo valor disponible, se lo pide al TreeCellEditor por medio del método treeCellEditor.getCellEditorValue(). Entonces TreeCellEditor le devuelve el nuevo valor y todos contentos, Federico Ratón ve su nuevo valor en el nodo del árbol.

Bueno, esto tan liado es lo básico. Hay alguna cosilla más que comentaremos por encima, pero no nos preocuparemos demasiado por ello.

Ahora que sabemos lo mínimo imprescindible, vamos a hacer nuestro propio editor.

Construir nuestro propio TreeCellEditor

Vamos a contruir nuestro propio editor con un JComboBox, para que nos quede tal que así

Para contruir nuestro propio TreeCellEditor sólo debemos hacer una clase que implemente TreeCellEditor e implementar todos sus métodos. Vamos a ver qué métodos son esos y cómo implementarlos.

public Component getTreeCellEditorComponent(JTree tree, Object value, boolean isSelected, boolean expanded, boolean leaf, int row)
public void addCellEditorListener(CellEditorListener l)
public void cancelCellEditing()
public Object getCellEditorValue()
public boolean isCellEditable(EventObject arg0)
public void removeCellEditorListener(CellEditorListener arg0)
public boolean shouldSelectCell(EventObject arg0)
public boolean stopCellEditing()

• getTreeCellEditor(). Este es el que comentamos antes. Este método debe devolver el Component que hace de editor, rellenándolo previamente con el value que recibe. El resto de parámetros son para por si necesitamos algo o queremos hacer algo especial en función de que el nodo esté o no seleccionado, sea hoja o no, esté expandido...
• addCellEditorListener(). Aquí es donde nos pasan al que debemos avisar cuando se acepte o cancele la edición. Para poder hacer esto, debemos hacer dos cosas:
  • Debermos añadir los ActionListener, EventListener o lo que sea al Component que devolvemos en el método anterior, para saber nosotros cuándo termina la edición.
  • Guardarnos el CellEditorListener que nos pasan, para avisarle cuando se acepte o cancele la edición
• cancellCellEditing(). A este método nos llamará el JTree cuando se pulse en otro nodo distinto del que se está editando. En principio no debemos hacer nada especial, salvo que al cancelar una edición a medias necesitemos hacer algo. Por ejemplo, si mientras editamos nos conectamos a una base de datos o abrimos un fichero, en este cancel podríamos cerrar la conexión o el fichero sin realizar cambios en la base de datos o fichero.
• getCellEditorValue(). Federico Ratón ha terminado de editar y ha aceptado la edición. Debemos devolver el nuevo valor que Federico Ratón ha metido en el Component que hace de editor.
• isCellEditable(). Federico Ratón ha hecho algo con el nodo. ¿Es ese algo lo que hay que hacer para editarlo, como un triple click?. Debemos devolver true si es así.
• removeCellEditorListener(). Como se supone que ha terminado la edición, JTree nos dice que no le avisemos más. Debemos borrrar el CellEditorListener que nos pase si lo teníamos guardado de antes.
• shouldSelectCell(). Ha comenzado la edición y JTree nos pregunta si puede olvidarse de los demás nodos que haya seleccionados y debe seleccionar el de la edición. Si queremos que sea así, devolvemos true. Si queremos que el editar un nodo no implique cambios en la selección de los demás, debemos devolver false.
• stopCellEditing(). Habitualmente JTree no llamará a este método por defecto, salvo que cambiemos el comportamiento. De alguna forma, nos avisa de que la edición ha terminado y que debemos revisar si el valor introducido en el editor por Federico Ratón es o no válido (por ejemplo, que ha metido un número si le estamos pidiendo un número y no un "aaa"). Devolvemos true si el contenido del editor es correcto y false en caso contrario. De todas formas, insisto, por defecto no nos llamarán a este método.

Listo. Ya sabemos lo que son todos esos métodos y una pequeña idea de cómo implementarlos.

En nuestro ejemplo vamos a poner como editor un JComboBox que permita elegir "abuelo", "padre", "tio", "hijo" e "hija". La implementación de la clase puede ser como esta MiTreeEditor.java.

Un par de detalles nada más:

• Hemos puesto una LinkedList<CellEditorListener> para guardar y borrar todos los CellEditorListener que nos pasen.
• Al JComboBox le hemos añadido un ActionListener para avisar a los CellEditorListener que tengamos guardados en la lista anterior cuando Federico Ratón seleccione algo.
• No me he preocupado mucho del tema, pero nuestro editor debería en realidad se un panel con el icono del árbol más el JComboBox. Al no ser así, mientras editamos el icono desaparece.

Para meter este editor en el árbol, basta con hacer la siguiente llamada

tree.setEditable(true);
tree.setCellEditor(new MiTreeEditor());

En PruebaJTree4.java tienes el código completo para crear y visualizar el JTree. Y creo que con esto vale de momento.

Estadísticas y comentarios

Numero de visitas desde el 4 Feb 2007:

• Esta pagina este mes: 16
• Total de esta pagina: 35818
• Total del sitio: 42384700