Soy totalmente nuevo en cuanto a la programación de GUI y quizás mi problema tenga una solución bastante simple. Estoy intentando implementar una interfaz gráfica de usuario de Java Swing que sirve como editor para una estructura de datos similar a un árbol. La GUI se divide en tres partes:

Un visor de árbol en el cuarto izquierdo de la ventana muestra los datos estructurados del árbol.

El área superior derecha grande muestra editores que contienen campos de texto, tablas y similares. Cada tipo diferente de objeto en la estructura de árbol tiene su propio editor que se muestra cuando se selecciona en el visor de árbol.

El área inferior derecha muestra un visor de consola. Se utiliza para mostrar mensajes sobre acciones específicas.

Me estoy esforzando por obedecer una separación estricta del modelo de su visualización en los visores / editores de árboles de mi programa. Por lo tanto, creé una instancia de una subclase de DefaultTreeModel (MyTreeModel) que almacena referencias a los datos de negocios y una instancia de una subclase de JTree que proporciona la representación visual de la estructura de árbol.

Estoy intentando implementar una funcionalidad que modifique los datos usando clases de Acción. Cualquier acción (como CreateNode, RenameNode, DeleteNode) se implementa en su propia clase de acción (subclase de AbstractAction). Las acciones se utilizan en el menú contextual del visor de árbol y en el menú "Editar" de las aplicaciones. Pero también quiero reutilizar algunos de ellos en las partes del editor de la GUI, por ejemplo. La acción RenameNode. Y aquí estoy actualmente atascado.

El visor de árbol muestra un icono junto con el nombre de cada nodo en el árbol. Y el editor respectivo contiene, entre otras cosas, también un JTextField que muestra el nombre del nodo asociado.

Sé que puedo adjuntar objetos de acción a JMenu, JPopupMenu e incluso a objetos JTextField utilizando el método setAction. Lo hice y ahora tengo una entrada de menú "Renombrar" en el menú "Editar" del programa, en el menú emergente asociado con el JTree que representa el visor de árbol y el JTextField que muestra el nombre del nodo también tiene esta acción asociada.

Para cambiar el atributo "Nombre" de un nodo de árbol, creé la clase RenameNode como una subclase de AbstractAction. Como ya se mencionó, el nombre se muestra en cada nodo en el visor de árbol y la acción simplemente hace que este texto sea editable. El código que hace esto tiene el siguiente aspecto (en la clase RenameNode):

public void actionPerformed(ActionEvent ev) {
    // "mouseOverPath" is the Treepath were the mouse was placed on
    // when the popup menu was opened
    if (tree.existsMouseOverPath()) {
        tree.startEditingAtPath(tree.mouseOverPath);
    } else if (tree.getSelectionCount() != 0) {
        tree.startEditingAtPath(tree.getSelectionPath());
    }
}

Estas son las declaraciones necesarias para que la acción funcione correctamente desde:

- el menú emergente (primera instrucción if; aquí se hace editable el objeto que estaba debajo del mouse cuando se abre el menú emergente)

- el menú de la aplicación (segunda sentencia if; aquí el nodo de árbol que está seleccionado actualmente, si es que hay alguno, se puede editar).

Bueno, esto funciona bien, en principio, pero de hecho, el cambio de nombre del nodo no se realiza a través del código en el método actionPerformed (ActionEvent ev) de la clase RenameAction. El cambio real del nombre del nodo se ejecuta en la clase MyTreeModel del árbol en el método valueForPathChanged () que se anula de la siguiente manera:

public class MyTreeModel extends DefaultTreeModel {


[...]

    @Override
    public void valueForPathChanged(TreePath path, Object newValue) {
    final MyTreeNode aNode = (MyTreeNode)path.getLastPathComponent();
    if (newValue instanceof String) {
        ((MyNode) aNode.getUserObject()).setName((String) newValue);
    } else {
        aNode.setUserObject(newValue);
    }
        nodeChanged(aNode);
    }

[...]

}

No tengo absolutamente ninguna idea de cómo el concepto de acciones podría aplicarse correctamente aquí. Aún peor es la situación con la operación de cambio de nombre cuando se realiza cambiando el texto en el objeto JTextField. Por el momento no sé cómo implementar eso de una manera limpia. El JTextField debe asociarse con un solo nodo de la estructura del modelo de árbol como su modelo y la acción adjunta debe modificar ese modelo y cuando se cambie este modelo, el visor de árbol deberá recibir una notificación para actualizar el nombre del nodo respectivo en el visor de árbol.

Supongo que la clase MyNode (que es alrady una subclase de DefaultMutableTreeNode) tendría que implementar el documento de interfaz y la clase RenameAction tendría que modificarlo y luego se tendría que emitir un evento para notificar al visor de árbol que muestra el nodo cambiado

Conclusión: debo admitir que aún no entendí completamente cómo implementar correctamente una acción que se usará en múltiples lugares en una GUI y no entiendo completamente cómo implementar un modelo que puedan usar varios objetos de GUI (en mi caso un JTree y un JTextField). Posiblemente todo eso es bastante simple ...

¡Gracias de antemano por cualquier ayuda!

Bueno, las respuestas proporcionadas fueron muy útiles para explicar cómo se pueden usar las acciones junto con JTrees. Pero hay un punto más que me gustaría discutir. En mi GUI tengo una representación de árbol de mis datos de negocios combinados con editores para los datos (el árbol ubicado en el cuarto izquierdo de la ventana y aparte de él un editor específico de tipo de nodo). Todos los nodos tienen nombres que pueden ser cambiados. Y, los editores contienen un campo de texto (implementado con un JTextField) en el que se muestra el nombre del nodo y que también se puede editar. Mi incertidumbre aquí es la siguiente: Un JTextField permite asignar un objeto de acción, así como un modelo para él. En realidad, el modelo sería un objeto de nodo ya visto en el JTree. Creo que debería haber una manera de usar el mismo objeto de modelo utilizado en JTree también como modelo para JTextField en el editor y también reutilizar la clase Action. Respecto a la reutilización del modelo, creo que mi clase de modelo MyTreeNode también tendrá que implementar la interfaz del documento, ¿correcto? Y al abrir el editor específico del nodo, tendría que asociar el nodo actualmente seleccionado en el JTree con el objeto JTextField utilizando su método setDocument (). Finalmente, mi RenameNodeAction tendría que realizar el cambio del nombre del nodo de JTextField. Así que mi punto central es: hacer que un modelo se muestre en múltiples vistas y la reutilización de una sola RenameAction en todos los lugares donde se va a renombrar un nodo. ¿Tiene sentido esto y es mi idea de cómo esto debe lograrse?