Comment puis-je actualiser un JTree après avoir ajouté des nœuds au modèle sous-jacent?

J'ai affronté le même "problème": l'appel de treeNodesInserted() n'est pas la cause de mon JTree de mettre à jour son contenu.

Mais le problème était dans un autre endroit: j'ai utilisé le mauvais constructeur de TreeModelEvent. J'ai pensé que je puisse créer TreeModelEvent pour treeNodesInserted() comme ça:

//-- Wrong!!
TreePath path_to_inserted_item = /*....*/ ;
TreeModelEvent tme = new TreeModelEvent(my_source, path_to_inserted_item);

Cela ne fonctionne pas.

Comme indiqué dans TreeModelEvent docsce constructeur n'est nécessaire pour treeStructureChanged(). Mais pour treeNodesInserted()treeNodesRemoved()treeNodesChanged() nous devrions utiliser un autre constructeur:

TreePath path_to_parent_of_inserted_items = /*....*/ ;
int[] indices_of_inserted_items = /*....*/ ;
Object[] inserted_items = /*....*/ ;
TreeModelEvent tme = new TreeModelEvent(
      my_source,
      path_to_parent_of_inserted_items,
      indices_of_inserted_items,
      inserted_items
   );

Ce code fonctionne, et JTree les mises à jour de son contenu correctement.

---

UPD: en Fait, les docs ne sont pas claires sur l'utilisation de ces TreeModelEvents, et surtout avec JTreedonc, je veux parler de certaines des questions qui m'est venue quand j'ai essayé de comprendre comment faire face à tout ce genre de choses.

Tout d'abord, comme Paralife noté son commentaire, les cas où l'insertion des nœuds/modifiés/supprimés, ou lorsque la structure de l'arbre est modifiée, ne sont pas orthogonaux. Donc,

Question #1: quand doit-on utiliser treeNodesInserted()/Changed()/Removed()et quand treeStructureChanged()?

Réponse: treeNodesInserted()/Changed()/Removed() peut être utilisé si seulement tous les nœuds touchés ont le même parent. Sinon, vous pouvez faire plusieurs appels à ces méthodes, ou tout simplement appeler treeStructureChanged() une fois (et passer le nœud racine de nœuds touchés). Donc, treeStructureChanged() est une sorte de manière universelle, tandis que treeNodesInserted()/Changed()/Removed() sont plus spécifiques.

Question #2: autant Que treeStructureChanged() est un moyen universel, pourquoi ai-je besoin pour faire face à ces treeNodesInserted()/Changed()/Removed()? Appelez simplement à treeStructureChanged() semble plus facile.

Réponse: Si vous utilisez JTree pour afficher le contenu de votre arbre, puis, le lendemain c'est peut-être un surprize pour vous (comme pour moi) : lorsque vous appelez treeStructureChanged()puis JTree permet de ne pas garder d'étendre l'état de sous-nœuds! Prenons l'exemple, voici le contenu de notre JTree maintenant:

[A]
 |-[B]
 |-[C]
 |  |-[E]
 |  |  |-[G]
 |  |  |-[H]
 |  |-[F]
 |     |-[I]
 |     |-[J]
 |     |-[K]
 |-[D]

Ensuite vous apporter quelques modifications à C (par exemple, renommer C2), et que vous appelez treeStructureChanged():

  myTreeModel.treeStructureChanged(
        new TreeModelEvent(
           this,
           new Object[] { myNodeA, myNodeC } //Path to changed node
           )
        );

Ensuite, les nœuds E et F sera effondré! Et votre JTree ressemblera à cela:

[A]
 |-[B]
 |-[C2]
 |  +-[E]
 |  +-[F]
 |-[D]

Pour éviter cela, vous devez utiliser treeNodesChanged()comme ça:

  myTreeModel.treeNodesChanged(
        new TreeModelEvent(
           this,
           new Object[] { myNodeA }, //Path to the _parent_ of changed item
           new int[] { 1 },          //Indexes of changed nodes
           new Object[] { myNodeC }, //Objects represents changed nodes
                                     //   (Note: old ones!!! 
                                     //    I.e. not "C2", but "C",
                                     //    in this example)
           )
        );

Ensuite, l'expansion de l'etat sera maintenue.

---

J'espère que ce post sera utile à quelqu'un.

J'ai aussi trouvé la mise en œuvre de TreeModel un peu déroutant lorsque l'arbre se composent de plus que juste des Dossiers(la racine) et de Fichiers(enfant), j'ai donc utilisé la DefaultTreeModel. Cela fonctionne pour moi. La méthode crée ou actualise le JTree. Espérons que cette aide.

    public void constructTree() {       

        DefaultMutableTreeNode root =
                new DefaultMutableTreeNode(UbaEnv.DB_CONFIG);
        DefaultMutableTreeNode child = null;

        HashMap<String, DbConfig> dbConfigs = env.getDbConfigs();
        Iterator it = dbConfigs.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry) it.next();
            child = new DefaultMutableTreeNode(pair.getKey());

            child.add(new DefaultMutableTreeNode(UbaEnv.PROP));
            child.add(new DefaultMutableTreeNode(UbaEnv.SQL));
            root.add(child);
        }

        if (tree == null) {
            tree = new JTree(new DefaultTreeModel(root));
            tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
            tree.addTreeSelectionListener(new TreeListener());
        } else {
            tree.setModel(new DefaultTreeModel(root));
        }
}

Hier, j'ai struggeled autour pour résoudre le même problème. L'exigence était d'insérer et de supprimer des nœuds à la volée, sans réduction de l'étendu des nœuds de l'arborescence. J'ai parcouru le web et trouvé un tas de solutions possibles, jusqu'à ce que je suis tombé sur ce fil. Puis j'ai appliqué la réponse de "Dimitri Frank" avec le TreeModelEvent. J'ai été un peu confus, pourquoi c'est un gros problème pour insérer ou supprimer un nœud simple et de laisser le reste de la JTree intacte!
Enfin la plaine de vanille exemples de java2s m'a aidé à trouver le probablement la solution la plus simple. (Ni un appel comme: nodeStructureChanged, nodeChanged, nodesWereRemoved, nodesWereInserted, etc. ni une TreeModelEvent comme suggéré par "Dimitri Frank" a été requis.)

---

Voici ma solution:

//Remove a node
treeModel.removeNodeFromParent(myNode);

//Insert a node (Actually this is a reinsert, since I used a Map called `droppedNodes` to keep the previously removed nodes. So I don't need to reload the data items of those nodes.)
MyNode root = treeModel.getRootNode();
treeModel.insertNodeInto(droppedNodes.get(nodeName), root, root.getChildCount());

Faire simple 😉

Par exemple:Jtree Actualiser de façon dynamique

package package_name;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;

public final class homepage extends javax.swing.JFrame implements ActionListener
{
     DefaultTreeModel model;
     DefaultMutableTreeNode root;
     File currentDir = new File("database");

public homepage() throws InterruptedException {
        initComponents();
    //------full screen window
        this.setExtendedState(MAXIMIZED_BOTH);
    //====================Jtree Added Details..   

    //result is the variable name for jtree
        model =(DefaultTreeModel) treedbnm.getModel();
    //gets the root of the current model used only once at the starting
        root=(DefaultMutableTreeNode) model.getRoot();
    //function called   
        dbcreate_panel1();
        Display_DirectoryInfo(currentDir,root);

}//End homepage() Constructor
public void Display_DirectoryInfo(File dir,DefaultMutableTreeNode tmp_root) throws InterruptedException 
{..........   
}
public void dbcreate_panel1()
{
    //------------------Jtree Refresh Dynamically-------------------//
             root.removeFromParent();
             root.removeAllChildren();
             model.reload();
             Display_DirectoryInfo(currentDir,root);
}
}//End homepage