Java dynamique JTree

Question

Je veux trouver la méthode qui ajoute dynamiquement des nœuds à un JTree, en regardant à travers la documentation et les exemples, cela ne peut être fait qu'au constructeur de JTree.

Si possible, montrez-moi les extraits de code pour cela.

Merci d'avance.

Answer 1

Essayez this

Modifier avec plus d'explications: vous voulez que votre modèle d'arbre à être basé sur MutableTreeNode. Le lien ci-dessus est un exemple du tutoriel Sun.

Answer 2

Vous devez avoir une implémentation personnalisée d'un TreeModel et TreeNode, voir ci-dessous. Étendez simplement LazyTreeModel et implémentez loadChildren().

Il quelques dépendances que vous devez remplacer par vos implémentations:. LOG - votre enregistreur et WorkerManager.getInstance() programme (nouvelle LoadNodesWorker()), vous pouvez le remplacer par un fil() - travailleur est l'équivalent de Runnable.

public abstract class LazyTreeModel extends DefaultTreeModel implements TreeWillExpandListener { 

public LazyTreeModel(TreeNode root, JTree tree) { 
    super(root); 
    setAsksAllowsChildren(true); 
    tree.addTreeWillExpandListener(this); 
    tree.setModel(this); 
} 

public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException { 
    LazyTreeNode node = (LazyTreeNode) event.getPath().getLastPathComponent(); 
    if (node.isLoaded()) { 
     return; 
    } 
    setLoading(node, false); 
    WorkerManager.getInstance().schedule(new LoadNodesWorker(node)); 
} 

public void reloadNode(String id) { 
    LazyTreeNode node = findNode(id); 
    if (node != null) { 
     node.setLoaded(false); 
     setLoading(node, true); 
     WorkerManager.getInstance().schedule(new LoadNodesWorker(node)); 
    } 
} 

public void reloadParentNode(String id) { 
    LazyTreeNode node = findParent(id); 
    if (node != null) { 
     node.setLoaded(false); 
     setLoading(node, true); 
     WorkerManager.getInstance().schedule(new LoadNodesWorker(node)); 
    } 
} 

public LazyTreeNode findParent(String id) { 
    LazyTreeNode node = findNode(id); 
    if (node != null && node.getParent() != null) { 
     return (LazyTreeNode) node.getParent(); 
    } 
    return null; 
} 

public void loadFirstLevel() { 
    setLoading((LazyTreeNode) getRoot(), false); 
    WorkerManager.getInstance().schedule(new LoadNodesWorker((LazyTreeNode) getRoot())); 
} 

public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException { 
} 

protected void setChildren(LazyTreeNode parentNode, LazyTreeNode... nodes) { 
    if (nodes == null) { 
     return; 
    } 
    int childCount = parentNode.getChildCount(); 
    if (childCount > 0) { 
     for (int i = 0; i < childCount; i++) { 
      removeNodeFromParent((MutableTreeNode) parentNode.getChildAt(0)); 
     } 
    } 
    for (int i = 0; i < nodes.length; i++) { 
     insertNodeInto(nodes[i], parentNode, i); 
    } 
} 

private void setLoading2(final LazyTreeNode parentNode, final boolean reload) { 
    if (reload) { 
     setChildren(parentNode, createReloadingNode()); 
    } else { 
     setChildren(parentNode, createLoadingNode()); 
    } 
} 

private void setLoading(final LazyTreeNode parentNode, final boolean reload) { 
    if (SwingUtilities.isEventDispatchThread()) { 
     setLoading2(parentNode, reload); 
    } else { 
     try { 
      SwingUtilities.invokeAndWait(new Runnable() { 
       public void run() { 
        setLoading2(parentNode, reload); 
       } 
      }); 
     } catch (Exception e) { 
      LOG.error("Cannot create loading node", e); 
     } 
    } 
} 

private LazyTreeNode findNode(String id) { 
    return findNode(id, (LazyTreeNode) getRoot()); 
} 

private LazyTreeNode findNode(String id, LazyTreeNode parent) { 
    int count = parent.getChildCount(); 
    for (int i = 0; i < count; i++) { 
     LazyTreeNode node = (LazyTreeNode) parent.getChildAt(i); 
     if (id.equals(node.getId())) { 
      return node; 
     } 
     if (node.isLoaded()) { 
      node = findNode(id, node); 
      if (node != null) { 
       return node; 
      } 
     } 
    } 
    return null; 
} 

public abstract LazyTreeNode[] loadChildren(LazyTreeNode parentNode); 

protected LazyTreeNode createLoadingNode() { 
    return new LazyTreeNode(null, "Loading...", false); 
} 

protected LazyTreeNode createReloadingNode() { 
    return new LazyTreeNode(null, "Refreshing...", false); 
} 

class LoadNodesWorker implements Worker { 

    private LazyTreeNode parentNode; 

    LoadNodesWorker(LazyTreeNode parent) { 
     this.parentNode = parent; 
    } 

    public String getName() { 
     return "Lazy loading of node " + parentNode.getId(); 
    } 

    public void execute() throws Exception { 
     final LazyTreeNode[] treeNodes = loadChildren(parentNode); 
     if (treeNodes == null) { 
      return; 
     } 
     SwingUtilities.invokeLater(new Runnable() { 
      public void run() { 
       parentNode.setLoaded(true); 
       setChildren(parentNode, treeNodes); 
      } 
     }); 
    } 
} 

}

public class LazyTreeNode extends DefaultMutableTreeNode { 

private boolean loaded; 
private String id; 

public LazyTreeNode(String id) { 
    this(id, null); 
} 

public LazyTreeNode(String id, Object userObject) { 
    this(id, userObject, true); 
} 

public LazyTreeNode(String id, Object userObject, boolean allowsChildren) { 
    super(userObject, allowsChildren); 
    this.id = id; 
} 

public String getId() { 
    return id; 
} 

protected boolean isLoaded() { 
    return loaded; 
} 

protected void setLoaded(boolean loaded) { 
    this.loaded = loaded; 
} 

@Override 
public boolean isLeaf() { 
    return !getAllowsChildren(); 
} 

}

Answer 3

Le tutoriel exemple Sun mentionné par I82Much, comprend un projet de démonstration, DynamicTreeDemo, qui est composé des deux fichiers source DynamicTreeDemo.java et DynamicTree.java. Vous devriez être en mesure d'obtenir à partir de ces liens.