public CategoryExplorerModel(CategoryNode node) 
{
  //--------------------------------------------------------------------------
  //   Private Variables:
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  //   Constructors:
  //--------------------------------------------------------------------------
    super(node);
}

 public synchronized  void addActionListener(ActionListener l) 
{
    _listener = AWTEventMulticaster.add(_listener, l);
}

 public CategoryNode addCategory(CategoryPath path) 
{
    CategoryNode root = (CategoryNode) getRoot();
    CategoryNode parent = root; // Start condition.
    for (int i = 0; i <  path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNode) children.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          break;
        }
      }
      if (categoryAlreadyExists == false) {
        // We need to add the node.
        CategoryNode newNode = new CategoryNode(element.getTitle());
        //This method of adding a new node cause parent roots to be
        // collapsed.
        //parent.add( newNode );
        //reload(parent);
        // This doesn't force the nodes to collapse.
        insertNodeInto(newNode, parent, parent.getChildCount());
        refresh(newNode);
        // The newly added node is now the parent.
        parent = newNode;
      }
    }
    return parent;
}

Method altered by Richard Hurst such that it returns the CategoryNode corresponding to the CategoryPath

 public  void addLogRecord(LogRecord lr) 
{
    CategoryPath path = new CategoryPath(lr.getCategory());
    addCategory(path); // create category path if it is new
    CategoryNode node = getCategoryNode(path);
    node.addRecord(); // update category node
    if (_renderFatal && lr.isFatal()) {
      TreeNode[] nodes = getPathToRoot(node);
      int len = nodes.length;
      CategoryNode parent;
      // i = 0 gives root node
      // skip node and root, loop through "parents" in between
      for (int i = 1; i <  len - 1; i++) {
        parent = (CategoryNode) nodes[i];
        parent.setHasFatalChildren(true);
        nodeChanged(parent);
      }
      node.setHasFatalRecords(true);
      nodeChanged(node);
    }
}

 public CategoryNode getCategoryNode(String category) 
{
    CategoryPath path = new CategoryPath(category);
    return (getCategoryNode(path));
}

 public CategoryNode getCategoryNode(CategoryPath path) 
{
    CategoryNode root = (CategoryNode) getRoot();
    CategoryNode parent = root; // Start condition.
    for (int i = 0; i <  path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNode) children.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          break; // out of the while, and back to the for().
        }
      }
      if (categoryAlreadyExists == false) {
        return null; // Didn't find the Node.
      }
    }
    return (parent);
}

returns null if no CategoryNode exists.

 public CategoryNode getRootCategoryNode() 
{
    return (CategoryNode) getRoot();
}

 public TreePath getTreePathToRoot(CategoryNode node) 
{
    if (node == null) {
      return null;
    }
    return (new TreePath(getPathToRoot(node)));
}

Returns the CategoryPath to the specified CategoryNode

 public boolean isCategoryPathActive(CategoryPath path) 
{
    CategoryNode root = (CategoryNode) getRoot();
    CategoryNode parent = root; // Start condition.
    boolean active = false;
    for (int i = 0; i <  path.size(); i++) {
      CategoryElement element = path.categoryElementAt(i);
      // If the two nodes have matching titles they are considered equal.
      Enumeration children = parent.children();
      boolean categoryAlreadyExists = false;
      active = false;
      while (children.hasMoreElements()) {
        CategoryNode node = (CategoryNode) children.nextElement();
        String title = node.getTitle().toLowerCase();
        String pathLC = element.getTitle().toLowerCase();
        if (title.equals(pathLC)) {
          categoryAlreadyExists = true;
          // This is now the new parent node.
          parent = node;
          if (parent.isSelected()) {
            active = true;
          }
          break; // out of the while, and back to the for().
        }
      }
      if (active == false || categoryAlreadyExists == false) {
        return false;
      }
    }
    return (active);
}

 protected  void notifyActionListeners() 
{
    if (_listener != null) {
      _listener.actionPerformed(_event);
    }
}

 protected  void refresh(CategoryNode node) 
{
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        nodeChanged(node); // remind the tree to render the new node
      }
    });
}

Fires a nodechanged event on the SwingThread.

 public synchronized  void removeActionListener(ActionListener l) 
{
    _listener = AWTEventMulticaster.remove(_listener, l);
}

 public  void resetAllNodeCounts() 
{
    Enumeration nodes = getRootCategoryNode().depthFirstEnumeration();
    CategoryNode current;
    while (nodes.hasMoreElements()) {
      current = (CategoryNode) nodes.nextElement();
      current.resetNumberOfContainedRecords();
      nodeChanged(current);
    }
}

 public  void setDescendantSelection(CategoryNode node,
    boolean selected) 
{
    Enumeration descendants = node.depthFirstEnumeration();
    CategoryNode current;
    while (descendants.hasMoreElements()) {
      current = (CategoryNode) descendants.nextElement();
      // does the current node need to be changed?
      if (current.isSelected() != selected) {
        current.setSelected(selected);
        nodeChanged(current);
      }
    }
    notifyActionListeners();
}

 public  void setParentSelection(CategoryNode node,
    boolean selected) 
{
    TreeNode[] nodes = getPathToRoot(node);
    int len = nodes.length;
    CategoryNode parent;
    // i = 0 gives root node, i=len-1 gives this node
    // skip the root node
    for (int i = 1; i <  len; i++) {
      parent = (CategoryNode) nodes[i];
      if (parent.isSelected() != selected) {
        parent.setSelected(selected);
        nodeChanged(parent);
      }
    }
    notifyActionListeners();
}

 public  void update(CategoryNode node,
    boolean selected) 
{
    if (node.isSelected() == selected) {
      return; // nothing was changed, nothing to do
    }
    // select parents or deselect children
    if (selected) {
      setParentSelection(node, true);
    } else {
      setDescendantSelection(node, false);
    }
}