How to use

AsyncTreeModel

in

jadex.base.gui.asynctree

/**
 * Set the root node.
 */
public void setRoot(ITreeNode root)
{
  if(this.root != null)
    deregisterNode(this.root);
  this.root = root;
  if (root != null)
    addNode(root);
  // System.err.println(""+hashCode()+" set root");
  fireTreeChanged(root);
}

/**
 *  Build a tree path to the given node.
 *  @param desc The node.
 *  @return The path items.
 */
@Override
public List buildTreePath(ITreeNode node)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  return super.buildTreePath(node);
}

  /**
   *  Inform listeners that a node has been added
   */
  @Override
  public void fireNodeAdded(ITreeNode parent, ITreeNode child, int index)
  {
//        if(child.toString().indexOf("A:")!=-1)
//            System.out.println("here4");

    assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
    
    super.fireNodeAdded(parent, child, index);
  }
  

/**
 * Add a child and update the tree. Must be called from swing thread.
 */
public void addChild(int index, ITreeNode node)
{
  // Ignore when node already removed.
  if(!model.isZombieNode(node.getId()))
  {
    // set parent to this
    ((AbstractTreeNode)node).setParent(this);
    
    if(children == null)
      children = new ArrayList();
    children.add(index, node);
    model.addNode(node);
    model.fireNodeAdded(this, node, index);
    if (searching)
      dirty = true;
    // if(node.getId().toString().startsWith("ANDTest@"))
    // System.out.println("Node added: "+node+", "+children);
  } 
  else
  {
    model.removeZombieNode(node);
  }
}

  model.fireNodeRemoved(AbstractTreeNode.this, node, i - removed);
  removed++;
  changed = true;
  model.addNode(node);
  model.fireNodeAdded(AbstractTreeNode.this, node, i);
  changed = true;
model.deregisterNode(node);
model.fireNodeChanged(AbstractTreeNode.this);

/**
 * Remove a child and update the tree. 
 */
public void removeChild(ITreeNode node)
{
  int index = getIndexOfChild(node);
  if(index != -1)
  {
    // boolean removed =
    children.remove(node);
    // if(node.getId().toString().startsWith("ANDTest@"))
    // System.out.println("removed: "+node+", "+removed);
    model.deregisterNode(node);
    model.fireNodeRemoved(this, node, index);
    if (searching)
      dirty = true;
  } 
  else
  {
    getModel().addZombieNode(node.getId());
  }
}

if (parents[i] == null || getAddedNode(parents[i].getId()) != null)
      if(getAddedNode(nodes[cnt].getId()) != null)
        indices = itmp;
      path = buildTreePath(parents[i]);
    indices = null;
    nodes = null;
    path = buildTreePath((ITreeNode) set.iterator().next());

/**
 *  Remove a node registration.
 */
@Override
public void	deregisterNode(ITreeNode node)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  
  super.deregisterNode(node);
}

/**
 *  Inform listeners that a node has been removed
 */
@Override
public void fireNodesRemoved(ITreeNode parent, ITreeNode[] childs, int[] indices)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  
  super.fireNodesRemoved(parent, childs, indices);
}

  /**
   *  Add a node.
   *  Informs listeners.
   */
  @Override
  public void	addNode(ITreeNode node)
  {
    assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();

//        System.out.println("added node: "+node);
    super.addNode(node);
  }
  

/**
 *  Inform listeners that a node has changed.
 */
@Override
public void fireNodeChanged(ITreeNode node)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  super.fireNodeChanged(node);	
}

/**
 *  Inform listeners that tree has changed from given node on.
 */
@Override
public void fireTreeChanged(ITreeNode node)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  
  super.fireTreeChanged(node);
}

/**
 *  Inform listeners that a node has been removed
 */
@Override
public void fireNodeRemoved(ITreeNode parent, ITreeNode child, int index)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  
  super.fireNodeRemoved(parent, child, index);
}

/**
 *  Get a node by its id.
 */
@Override
public ISwingTreeNode	getAddedNode(Object id)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  return (ISwingTreeNode) super.getAddedNode(id);
}

/**
 *  Check, if a node is a zombie.
 */
@Override
public boolean	isZombieNode(Object id)
{
  assert SwingUtilities.isEventDispatchThread();// ||  Starter.isShutdown();
  
  return super.isZombieNode(id);
}

if(!model.isZombieNode(node.getId()))
    children = new ArrayList();
  children.add(index, node);
  model.addNode(node);
  model.fireNodeAdded(this, node, index);
  if (searching)
    dirty = true;
  model.removeZombieNode(node);

/**
 * Remove a zombie node.
 */
public void removeZombieNode(ITreeNode node)
{
  synchronized(nodes)
  {
    Integer num = zombies.get(node.getId());
    if(num.intValue()>1)
    {
      num = Integer.valueOf(num.intValue()-1);
      zombies.put(node.getId(), num);
      // if(node.getId().toString().startsWith("ANDTest@"))
      // System.out.println("Zombie node count decreased: "+node+", "+num);
    }
    else
    {
      // if(node.getId().toString().startsWith("ANDTest@"))
      // System.out.println("Zombie node removed: "+node+", "+num);
      deregisterNode(node);
    }
  }
}

/**
 * Remove all children.
 */
public void removeAllChildren()
{
  if(children != null && children.size() > 0)
  {
    int[] indices = new int[children.size()];
    for(int i = 0; i < children.size(); i++)
    {
      indices[i] = i;
    }
    children.clear();
    model.fireNodesRemoved(this, children.toArray(new ITreeNode[children.size()]), indices);
    if (searching)
      dirty = true;
  }
}

/**
 * Add a node. Informs listeners.
 */
public void addNode(ITreeNode node)
{
  added.put(node.getId(), node);
  INodeListener[] lis = nodelisteners.toArray(new INodeListener[nodelisteners.size()]);
  for(int i = 0; i < lis.length; i++)
  {
    lis[i].nodeAdded(node);
  }
  for(int i = 0; i < node.getCachedChildren().size(); i++)
  {
    addNode((ITreeNode)node.getCachedChildren().get(i));
  }
}

  /**
   * Inform listeners that a node has been removed
   */
  public void fireNodesRemoved(ITreeNode parent, ITreeNode[] childs, int[] indices)
  {
    List<ITreeNode> path = buildTreePath(parent);

//        System.err.println(""+hashCode()+" Node removed: "+child+", "+index+", "+path);

    for(int i = 0; i < listeners.size(); i++)
    {
      listeners.get(i).treeNodesRemoved(new AsyncTreeModelEvent(this, path.toArray(), indices, childs));
    }
  }