configtree.java

这是一个用java和xml编写的流媒体服务器管理软件

    try
    {
      element = (Element) node;
    }
    catch (ClassCastException e)
    {
      System.out.println("currently selected node is not an element: " 
                         + node.getNodeValue());
    }

    return element;
  }

  /**
   * get type of currently selected TreeNode.
   */
  public int getSelectedNodeType()
  {
    DefaultMutableTreeNode currentNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();
    
    if (currentNode == null)
    {
      System.out.println("selected node is null");

      return UNKNOWN;
    }
    System.out.println("this is :" + currentNode.getUserObject());
    //System.out.println("_______________________________\n");
    UserObject theObject = (UserObject) (currentNode.getUserObject());    
    System.out.println("this is :" + theObject.getNodeType());
    return theObject.getNodeType();
    
  }

  /**
   * 
   */
  public MarshalData getMarshalData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public MarshalData getNewMarshalData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(MARSHAL_SERVER, this, thisNode);
  }

  /**
   * 
   */
  public FeatureData getFeatureData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public FeatureData getNewFeatureData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(FEATURE_SERVER, this, thisNode);
  }

  /**
   * 
   */
  public GroupData getGroupData()
  {
    int type = getSelectedNodeType();

    return dataManager;
  }

  /**
   * 
   */
  public GroupData getNewGroupData()
  {
    System.out.println("calling getNewGroupData");

    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();
    int type = getSelectedNodeType();

    return new DataFragment(FEATURE_GROUP, this, thisNode);
  }

  /**
   * 
   */
  public RedirectData getRedirectData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public RedirectData getNewRedirectData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(REDIRECT_SERVER, this, thisNode);
  }

  /**
   * 
   */
  public PDPData getPDPData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public PDPData getNewPDPData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(PDP_SERVER, this, thisNode);
  }

  public DvrData getDvrData()
  {
    return dataManager;
  }
  
  public DvrData getNewDvrData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(DVR, this, thisNode);
  }
  
  public EnvData getEnvData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public EnvData getNewEnvData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(ENV, this, thisNode);
  }
  /**
   * 
   */
  public OSPData getOSPData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public GlobalData getGlobalData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public DialPlanData getDialPlanData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public DialPlanData getNewDialPlanData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public CdrData getCdrData()
  {
    return dataManager;
  }
  

  /**
   * 
   */
  public CdrData getNewCdrData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(CDR_SERVER, this, thisNode);
  }
  
   
  /**
   * 
   */
  public HeartbeatData getHeartbeatData()
  {
    return dataManager;
  }

  /**
   * 
   */
  public HeartbeatData getNewHeartbeatData()
  {
    DefaultMutableTreeNode thisNode = 
      (DefaultMutableTreeNode) getLastSelectedPathComponent();

    return new DataFragment(HEARTBEAT_SERVER, this, thisNode);
  }

  // 
  // Classes
  // 

  /**
   * DOM tree model.
   */
  static class Model extends DefaultTreeModel implements Serializable
  {

    // 
    // Data
    // 

    /**
     * Document.
     */
    private Document treeDOM;

    /**
     * Node Map.
     */
    private Hashtable nodeMap = new Hashtable();

    /**
     * tree nodes to be expanded at initialization
     */
    Vector treeNodesToExpand = new Vector();

    // 
    // Constructors
    // 

    /**
     * Default constructor.
     */
    public Model()
    {
      super(new DefaultMutableTreeNode(new UserObject(UNKNOWN, "")));

      System.out.println("Building DOM tree");

      // create document
      try
      {
        this.treeDOM = FileToDOM.readFiles();
      }
      catch (Exception e)
      {
        e.printStackTrace();
      }

      // clear tree and re-populate
      ((DefaultMutableTreeNode) getRoot()).removeAllChildren();
      nodeMap.clear();
      buildTree();
      fireTreeStructureChanged(this, new Object[]
      {
        getRoot()
      }, new int[0], new Object[0]);

    }

    // 
    // Public methods
    // 

    /**
     * rebuilds the tree after the DOM has been modified
     */
    public synchronized DefaultMutableTreeNode rebuildTree(DefaultMutableTreeNode currentNode)
    {

      // clear branch and re-populate
      Node domNode = getNode(currentNode);
      DefaultMutableTreeNode parent = 
        (DefaultMutableTreeNode) (currentNode.getParent());

      parent.remove(currentNode);

      DefaultMutableTreeNode newNode = 
        (DefaultMutableTreeNode) (insertElementNode(domNode, parent));

      nodeStructureChanged(parent);

      return newNode;
    }

    /**
     * 
     */
    public Vector getTreeNodesToExpand()
    {
      return treeNodesToExpand;
    }

    /**
     * Returns the document.
     */
    public Document getTreeDOM()
    {
      return treeDOM;
    }

    /**
     * get the org.w3c.Node for a MutableTreeNode.
     */
    public Node getNode(Object treeNode)
    {
      return (Node) nodeMap.get(treeNode);
    }

    /**
     * replace an entry in nodeMap
     */
    public void replaceNodeInMap(Object key, Object replacement)
    {
      nodeMap.put(key, replacement);
    }

    /**
     * remove the org.w3c.Node from the nodeMap
     * and remove the associated TreeNode from the tree.
     * @return the parent of the node removed.
     */
    public DefaultMutableTreeNode deleteNode(DefaultMutableTreeNode treeNode)
    {
      DefaultMutableTreeNode treeParent = 
        (DefaultMutableTreeNode) treeNode.getParent();
      Enumeration childrenEnum = treeNode.children();
      DefaultMutableTreeNode child = null;

      while (childrenEnum.hasMoreElements())
      {
        child = (DefaultMutableTreeNode) childrenEnum.nextElement();

        deleteNode(child);
      }

      Object removedObject = nodeMap.remove(treeNode);

      System.out.println("removing " + removedObject.toString() 
                         + " from tree");

      if (removedObject instanceof Node)
      {

        // the nodemap also holds strings and possibly other things
        Node removedNode = (Node) removedObject;
        Node nodeParent = removedNode.getParentNode();

        if (nodeParent != null)
        {
          nodeParent.removeChild(removedNode);
        }
      }

      treeParent.remove(treeNode);
      nodeStructureChanged(treeNode);

      return treeParent;
    }

    /**
     * For all children of this node,
     * remove the org.w3c.Node from the nodeMap
     * and remove the associated TreeNode from the tree.
     */
    public void deleteChildrenOfNode(DefaultMutableTreeNode treeNode)
    {
      while (treeNode.getChildCount() > 0)
      {
        DefaultMutableTreeNode child = 
          (DefaultMutableTreeNode) treeNode.getFirstChild();

        deleteNode(child);
      }
    }

    // 
    // Private methods
    // 

    /**
     * Builds the tree.
     * Modified original to include a NodeFilter
     */

    private void buildTree()
    {


      // is there anything to do?
      if (treeDOM == null)
      {
        return;
      }

      // iterate over children of this node
      NodeList nodes = treeDOM.getChildNodes();
      int len = (nodes != null) ? nodes.getLength() : 0;
      MutableTreeNode root = (MutableTreeNode) getRoot();

      for (int i = 0; i < len; i++)
      {
        Node node = nodes.item(i);          
        switch (node.getNodeType())
        {

          case Node.DOCUMENT_NODE:
          {
            root = insertDocumentNode(node, root);

            break;
          }

          case Node.ELEMENT_NODE:
          {
            insertElementNode(node, root);

            break;
          }

          default:      // ignore

        }               // switch

      }                 // for

    }                   // buildTree()

    /**
     * Inserts a node and returns a reference to the new node.
     */
    private MutableTreeNode insertNode(String what, MutableTreeNode where)
    {
      return insertNode(what, where, UNKNOWN);
    }

    /**
     * Inserts a typed node and returns a reference to the new node.
     */
    private MutableTreeNode insertNode(String what, MutableTreeNode where, 
            int type)
    {

      MutableTreeNode node = new DefaultMutableTreeNode(new UserObject(type, 
              what));

      insertNodeInto(node, where, where.getChildCount());

      return node;

    }   // insertNode(Node,MutableTreeNode):MutableTreeNode


    /**
     * Inserts the document node.
     */
    private MutableTreeNode insertDocumentNode(Node what, 
            MutableTreeNode where)
    {
      MutableTreeNode treeNode = insertNode("<" + what.getNodeName() + '>', 
              where);

      nodeMap.put(treeNode, what);

      return treeNode;
    }

    /**
     * Inserts a document fragment.
     * Note that this only works for a fragment with a single
     * child. Returns the single child.
     */
    private DefaultMutableTreeNode insertFragmentNode(DocumentFragment what, 
            MutableTreeNode where)
    {