import javax.xml.parsers.*;
import org.xml.sax.*;
import java.io.*;
import org.w3c.dom.*;
import javax.swing.*;
import javax.swing.tree.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;


//Note: Large Portions of this code are courtesy of "The Java Tutorial" under
//GPL Open Source agreement. For the orgininal source please visit
//http://java.sun.com/xml/jaxp/dist/1.1/docs/tutorial/dom/index.html
public class SchemaInterpreter 
{
  //Code for XML Parsing Using DOM, removed for revisions
	/*
  // An array of names for DOM node-types
  // (Array indexes = nodeType() values.)
  static final String[] typeName = {"none",
                                    "Element",
                                    "Attr",
                                    "Text",
                                    "CDATA",
                                    "EntityRef",
                                    "Entity",
                                    "ProcInstr",
                                    "Comment",
                                    "Document",
                                    "DocType",
                                    "DocFragment",
                                    "Notation"};
                                    
  static final int ELEMENT_TYPE =   1;
  
  // The list of elements to display in the tree
  static String[] treeElementNames = {"slideshow",
                                      "slide",
                                      "title",         // For slideshow #1
                                      "slide-title",   // For slideshow #10
                                      "item"};
                                      
  public JTree tree;
  public Document document;
  public boolean compress = true;*/
	
	/**
	 * Default Constructor
	 */
	public SchemaInterpreter() 
	{
	}

  //Code for XML Parsing Using DOM, removed for revisions
  /*public SchemaInterpreter(Document x) 
  {
    tree = new JTree(new DomToTreeModelAdapter());
  }
  
  public JTree getResultantTree()
  {
    return tree;
  }
  
  boolean treeElement(String elementName) 
  {
    for (int i=0; i<treeElementNames.length; i++) 
    {
      if ( elementName.equals(treeElementNames[i]) ) 
        return true;
    }
    return false;
  }
  
  //Converts an unreadable DOM node to an AdapterNode which can display its
  //text value.
  public class AdapterNode
  {
    public org.w3c.dom.Node domNode;
    
    public AdapterNode(org.w3c.dom.Node node)
    {
      domNode = node;
    }
  
    public String toString()
    {
      String type = typeName[domNode.getNodeType()];
      String nodeName = domNode.getNodeName();
      
      if(domNode.getNodeValue() != null)
      {
        if(type.startsWith("ProcInstr"))
          type += ", ";
        else
          type += ": ";
          
        //Trim newlines from front of nodes
        String temp = domNode.getNodeValue().trim();
        int x = temp.indexOf("\n");
        if(x >= 0)
          temp = temp.substring(0,x);
        type = temp;
      }
      return type;
    }*/
  
    /*
     * Return children, index, and count values
     */
    //Code for XML Parsing Using DOM, removed for revisions
    /*public int index(AdapterNode child) 
    {
      System.err.println("Looking for index of " + child);
      int count = childCount();
      for (int i=0; i<count; i++) 
      {
        AdapterNode n = this.child(i);
        if (child.domNode == n.domNode) 
          return i;
      }
      return -1; // Should never get here.
    }
  
    public AdapterNode child(int searchIndex) 
    {
        //Note: JTree index is zero-based. 
        org.w3c.dom.Node node = domNode.getChildNodes().item(searchIndex);
        
        if (compress) 
        {
          // Return Nth displayable node
          int elementNodeIndex = 0;
          for (int i=0; i<domNode.getChildNodes().getLength(); i++) 
          {
            node = domNode.getChildNodes().item(i);
            
            if (node.getNodeType() == ELEMENT_TYPE 
                && treeElement( node.getNodeName() )
                && elementNodeIndex++ == searchIndex) 
            {
               break; 
            }
          }
        }
        return new AdapterNode(node); 
    }
  
    public int childCount() 
    {
        if (!compress) 
        {
          // Indent this
          return domNode.getChildNodes().getLength();  
        }
      
        int count = 0;
        
        for (int i=0; i<domNode.getChildNodes().getLength(); i++) 
        {
             org.w3c.dom.Node node = domNode.getChildNodes().item(i);
              
             if (node.getNodeType() == ELEMENT_TYPE
                 && treeElement( node.getNodeName() )) 
             {
             // Note: 
             //   Have to check for proper type. 
             //   The DOCTYPE element also has the right name
             ++count;
             }
        }
        return count;
      }
  }
  
    // This adapter converts the current Document (a DOM) into 
    // a JTree model. 
  public class DomToTreeModelAdapter implements javax.swing.tree.TreeModel 
  {
      // Basic TreeModel operations
      public Object  getRoot() 
      {
        //System.err.println("Returning root: " +document);
        return new AdapterNode(document);
      }
    
      public boolean isLeaf(Object aNode) 
      {
        // Determines whether the icon shows up to the left.
        // Return true for any node with no children
        AdapterNode node = (AdapterNode) aNode;
        if (node.childCount() > 0) return false;
        return true;
      }
    
      public int getChildCount(Object parent) 
      {
        AdapterNode node = (AdapterNode) parent;
        return node.childCount();
      }
    
      public Object getChild(Object parent, int index) 
      {
        AdapterNode node = (AdapterNode) parent;
        return node.child(index);
      }
    
      public int getIndexOfChild(Object parent, Object child) 
      {
        AdapterNode node = (AdapterNode) parent;
        return node.index((AdapterNode) child);
      }
    
      public void valueForPathChanged(TreePath path, Object newValue) 
      {
        // Null. We won't be making changes in the GUI
        // If we did, we would ensure the new value was really new,
        // adjust the model, and then fire a TreeNodesChanged event.
      }*/

      /*
       * Use these methods to add and remove event listeners.
       * (Needed to satisfy TreeModel interface, but not used.)
       */
      //Code for XML Parsing Using DOM, removed for revisions
      /*private Vector listenerList = new Vector();
      
      public void addTreeModelListener(TreeModelListener listener) 
      {
        if ( listener != null 
             && ! listenerList.contains( listener ) ) 
        {
          listenerList.addElement( listener );
        }
      }
    
      public void removeTreeModelListener(TreeModelListener listener) 
      {
        if ( listener != null ) 
        {
          listenerList.removeElement( listener );
        }
      }
    
      public void fireTreeNodesChanged( TreeModelEvent e ) 
      {
        Enumeration listeners = listenerList.elements();
        
        while ( listeners.hasMoreElements() ) 
        {
          TreeModelListener listener = (TreeModelListener) listeners.nextElement();
          listener.treeNodesChanged( e );
        }
      } 
      
      public void fireTreeNodesInserted( TreeModelEvent e ) 
      {
        Enumeration listeners = listenerList.elements();
        
        while ( listeners.hasMoreElements() ) 
        {
           TreeModelListener listener = (TreeModelListener) listeners.nextElement();
           listener.treeNodesInserted( e );
        }
      }
    
      public void fireTreeNodesRemoved( TreeModelEvent e ) 
      {
        Enumeration listeners = listenerList.elements();
        
        while ( listeners.hasMoreElements() ) 
        {
          TreeModelListener listener = (TreeModelListener) listeners.nextElement();
          listener.treeNodesRemoved( e );
        }
      }   
      
      public void fireTreeStructureChanged( TreeModelEvent e ) 
      {
        Enumeration listeners = listenerList.elements();
        
        while ( listeners.hasMoreElements() ) 
        {
          TreeModelListener listener = (TreeModelListener) listeners.nextElement();
          listener.treeStructureChanged( e );
        }
      }
  }*/

}