package net.logAnalyzer.gui.config;
   
   import java.util.Vector;
   
   import net.logAnalyzer.utils.gui.treetable.AbstractTreeTableModel;
   import net.logAnalyzer.utils.gui.treetable.TreeTableModel;
   
   import org.w3c.dom.Document;
   import org.w3c.dom.Element;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  
  /***
   * FileSystemModel is a TreeTableModel representing a hierarchical file system. Nodes in the
   * FileSystemModel are FileNodes which, when they are directory nodes, cache their children to avoid
   * repeatedly querying the real file system.
   * @version %I% %G%
   * @author Philip Milne
   * @author Scott Violet
   */
  
  public class XMLDocumentModel extends AbstractTreeTableModel implements TreeTableModel {
  
      // Names of the columns.
      static protected String[] cNames = {"Name", "Value"};
  
      // Types of the columns.
      static protected Class[] cTypes = {TreeTableModel.class, String.class};
  
      // The the returned file length for directories.
      public static final Integer ZERO = new Integer(0);
  
      private Document doc;
  
      public XMLDocumentModel(Document doc) {
          super(new XMLNode(doc.getDocumentElement()));
          Element node = doc.getDocumentElement();
          this.doc = doc;
      }
  
      //
      // Some convenience methods.
      //
  
      protected XMLNode getXMLNode(Object node) {
          XMLNode currentnode = ((XMLNode) node);
          return currentnode;
      }
  
      protected Object[] getChildren(Object node) {
          XMLNode currentnode = ((XMLNode) node);
          return currentnode.getChildren();
      }
  
      //
      // The TreeModel interface
      //
  
      public int getChildCount(Object node) {
          Object[] children = getChildren(node);
          return (children == null) ? 0 : children.length;
      }
  
      public Object getChild(Object node, int i) {
          return getChildren(node)[i];
      }
  
      // The superclass's implementation would work, but this is more efficient.
      public boolean isLeaf(Object node) {
          return !getXMLNode(node).hasChildNodes();
      }
  
      //
      // The TreeTableNode interface.
      //
  
      public int getColumnCount() {
          return cNames.length;
      }
  
      public String getColumnName(int column) {
          // return cNames[column];
          return null;
      }
  
      public Class getColumnClass(int column) {
          return cTypes[column];
      }
  
      public Object getValueAt(Object node, int column) {
          XMLNode currentnode = ((XMLNode) node);
          try {
              switch (column) {
              case 0:
                  return currentnode.toString();
              case 1:
                  return currentnode.getValue();
              default:
                 return new String("");
             }
         } catch (SecurityException se) {
         }
 
         return null;
     }
 }
 
 
 class XMLNode {
     Node element;
 
     Object[] children;
     String value;
 
     public XMLNode(Node element) {
         this.element = element;
     }
 
     /***
      * Returns the the string to be used to display this leaf in the JTree.
      */
     public String toString() {
         return element.getNodeName();
     }
 
     public Node getElement() {
         return element;
     }
 
     public int getNodeType() {
         return element.getNodeType();
     }
 
     public String getValue() {
         String returnValue=element.getNodeValue();
         if (element.getNodeType() == Node.ELEMENT_NODE){
             returnValue=this.value;
         }
         return returnValue;        
     }
 
     /***
      * Loads the children, caching the results in the children ivar.
      */
     protected Object[] getChildren() {
         if (children != null) {
             return children;
         }
         try {
             Vector childs = new Vector();
             NamedNodeMap attribs = element.getAttributes();
             if (attribs != null && attribs.getLength() > 0) {
                 for (int i = 0; i < attribs.getLength(); i++) {
                     Node node = attribs.item(i);
                     if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
                        XMLNode childNode = new XMLNode(node);
                        childs.add(childNode);
                     }
 
                 }
             }
             if (element.hasChildNodes()) {
                 NodeList nodelist = element.getChildNodes();
                 if (nodelist != null) {
                     // children = new XMLNode[nodelist.getLength()];
                     for (int i = 0; i < nodelist.getLength(); i++) {
                         Node node = nodelist.item(i);
                         if (node.getNodeType() != Node.TEXT_NODE) {
                             XMLNode childNode = new XMLNode(node);
                             childs.add(childNode);
                         }else{
                             this.value = node.getNodeValue();
                         }
 
                     }
                 }
             }
             children = childs.toArray();
         } catch (SecurityException se) {
         }
 
         return children;
     }
 
     protected boolean hasChildNodes() {
         boolean hasChild = false;
         if (getChildren().length > 0) {
             hasChild = true;
         } else {
             hasChild = false;
         }
         return hasChild;
     }
 }