// Copyright 2004-2005, FreeHEP.
   package hep.wired.util;
   
   import java.util.*;
   import javax.swing.*;
   import javax.swing.event.*;
   import javax.swing.tree.*;
   
   /***
   * TreeModel for TriStates.
   *
   * @author Mark Donszelmann
   * @version $Id: TristateTreeModel.java 672 2005-03-08 00:16:11Z duns $
   */
  public class TristateTreeModel implements TreeModel, TreeModelListener {
  
      protected List treeModelListeners = new ArrayList();
      protected TreeModel model;
      protected TristateTreeNode root;
  
      public TristateTreeModel() {
          this(null);
      }
  
      public TristateTreeModel(TreeModel model) {
          root = null;
          setModel(model);
      }
      
      public void setModel(TreeModel newModel) {
          if (model != null) {
              model.removeTreeModelListener(this);
          }
          model = newModel;
          if (model != null) {
              model.addTreeModelListener(this);
          }
          // NOTE: force a new setting of root
          root = null;
          root = (TristateTreeNode)getRoot();
          fireTreeStructureChanged();
      }
  
      // Delegated from tree
      public String convertValueToText(Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) {
          return value != null ? value.toString() : "null";
      } 
      
      protected void checkForChildren(TristateTreeNode parent, TreeModel model, boolean recursive) {
          Object modelParent = parent.getUserObject();
          int n = model.getChildCount(modelParent);
          if (parent.getChildCount() != n) {
              for (int i=0; i<n; i++) {
                  TristateTreeNode child = createTreeNode(model.getChild(modelParent, i));
                  parent.add(child);
                  if (recursive) checkForChildren(child, model, recursive);
              }
          }
      }
  
      protected TristateTreeNode createTreeNode(Object modelNode) {
          return new DefaultTristateTreeNode(modelNode);
      }
      
      public Set/*<Object>*/ getSelectedSet(Class type) {
          return getSelectedSet(type, Integer.MAX_VALUE);
      }
      
      public Set/*<Object>*/ getSelectedSet(Class type, int maxLevel) {
          Set set = new HashSet();
          TristateTreeNode node = (TristateTreeNode)getRoot();
          if ((node != null) && (node.getState() != TristateCheckBox.NOT_SELECTED)) {
              addSelected(set, node, type, Math.max(maxLevel, maxLevel+2));
          }
          return set;
      }
  
      private void addSelected(Set/*<Object>*/ set, TristateTreeNode node, Class type, int level) {
          if (level <= 0) return;
          if (node.isSelected()) {
              Object object = node.getUserObject();
              if ((type == null) || type.isAssignableFrom(object.getClass())) {
                  set.add(object);
              }
          }
          int n = getChildCount(node);
          for (int i=0; i<n; i++) {
              TristateTreeNode child = (TristateTreeNode)getChild(node, i);
              if (child.getState() != TristateCheckBox.NOT_SELECTED) {
                  addSelected(set, child, type, level-1);
              }
          }
      }
      
  // TreeModelListener
      public Object getRoot() {
          if ((root == null) && (model != null) && (model.getRoot() != null)) {
              root = new DefaultTristateTreeNode(model.getRoot());
              checkForChildren(root, model, true);
         }
         return root;
     }
 
     public Object getChild(Object parent, int index) {
         return ((TristateTreeNode)parent).getChildAt(index);
     }
                            
     public int getChildCount(Object parent) {
         return ((TristateTreeNode)parent).getChildCount(); 
     }
     
     public boolean isLeaf(Object node) {
         return getChildCount(node) == 0;
     }
 
     public void valueForPathChanged(TreePath path, Object newValue) {
         // FIXME, WIRED-390 maybe newvalue needs converting
         if (model != null) model.valueForPathChanged(path, newValue);
         treeNodesChanged(new TreeModelEvent(this, path));
     }
 
     public int getIndexOfChild(Object parent, Object child) {
         if ((parent instanceof TreeNode) && (child instanceof TreeNode)) {
             return ((TreeNode)parent).getIndex((TreeNode)child);
         }
         return -1;
     }
     
     public void addTreeModelListener(TreeModelListener l) {
         treeModelListeners.add(l);
     }
 
     public void removeTreeModelListener(TreeModelListener l) {
         treeModelListeners.remove(l);
     }   
 
     public void fireTreeStructureChanged() {
         if (root == null) return;
         
         TreeModelEvent e = new TreeModelEvent(this, new Object[] { root } );
         for (Iterator i=treeModelListeners.iterator(); i.hasNext(); ) {
             ((TreeModelListener)i.next()).treeStructureChanged(e);
         }
     }
 
 // TreeModelListener
     public void treeNodesChanged(TreeModelEvent e) {
         for (Iterator i=treeModelListeners.iterator(); i.hasNext(); ) {
             ((TreeModelListener)i.next()).treeNodesChanged(e);
         }
     }
 
     public void treeNodesInserted(TreeModelEvent e) {
         // FIXME, WIRED-390 check if we need to recreate/modify the tree
         for (Iterator i=treeModelListeners.iterator(); i.hasNext(); ) {
             ((TreeModelListener)i.next()).treeNodesInserted(e);
         }
     }
     
     public void treeNodesRemoved(TreeModelEvent e) {
         // FIXME, WIRED-390 check if we need to recreate/modify the tree
         for (Iterator i=treeModelListeners.iterator(); i.hasNext(); ) {
             ((TreeModelListener)i.next()).treeNodesRemoved(e);
         }
     }   
 
     public void treeStructureChanged(TreeModelEvent e) {
         // FIXME, WIRED-390 check if we want to do this...
         root = null;
         for (Iterator i=treeModelListeners.iterator(); i.hasNext(); ) {
             ((TreeModelListener)i.next()).treeStructureChanged(e);
         }
     }
 }