elementtreepanel.java

此程序是用标准的JAVA2实现的一个notepad程序

    // TreeSelectionListener

    /**
      * Called whenever the value of the selection changes.
      * @param e the event that characterizes the change.
      */
    public void valueChanged(TreeSelectionEvent e) {
	JTree       tree = getTree();

	if(!updatingSelection && tree.getSelectionCount() == 1) {
	    TreePath      selPath = tree.getSelectionPath();
	    Object        lastPathComponent = selPath.getLastPathComponent();

	    if(!(lastPathComponent instanceof DefaultMutableTreeNode)) {
		Element       selElement = (Element)lastPathComponent;

		updatingSelection = true;
		try {
		    getEditor().select(selElement.getStartOffset(),
				       selElement.getEndOffset());
		}
		finally {
		    updatingSelection = false;
		}
	    }
	}
    }

    // Local methods

    /**
     * @return tree showing elements.
     */
    protected JTree getTree() {
	return tree;
    }

    /**
     * @return JTextComponent showing elements for.
     */
    protected JTextComponent getEditor() {
	return editor;
    }

    /**
     * @return TreeModel implementation used to represent the elements.
     */
    public DefaultTreeModel getTreeModel() {
	return treeModel;
    }

    /**
     * Updates the tree based on the event type. This will invoke either
     * updateTree with the root element, or handleChange.
     */
    protected void updateTree(DocumentEvent event) {
	updatingSelection = true;
	try {
	    TreeModel        model = getTreeModel();
	    Object           root = model.getRoot();

	    for(int counter = model.getChildCount(root) - 1; counter >= 0;
		counter--) {
		updateTree(event, (Element)model.getChild(root, counter));
	    }
	}
	finally {
	    updatingSelection = false;
	}
    }

    /**
     * Creates TreeModelEvents based on the DocumentEvent and messages
     * the treemodel. This recursively invokes this method with children
     * elements.
     * @param event indicates what elements in the tree hierarchy have
     * changed.
     * @param element Current element to check for changes against.
     */
    protected void updateTree(DocumentEvent event, Element element) {
        DocumentEvent.ElementChange ec = event.getChange(element);

        if (ec != null) {
	    Element[]       removed = ec.getChildrenRemoved();
	    Element[]       added = ec.getChildrenAdded();
	    int             startIndex = ec.getIndex();

	    // Check for removed.
	    if(removed != null && removed.length > 0) {
		int[]            indices = new int[removed.length];

		for(int counter = 0; counter < removed.length; counter++) {
		    indices[counter] = startIndex + counter;
		}
		getTreeModel().nodesWereRemoved((TreeNode)element, indices,
						removed);
	    }
	    // check for added
	    if(added != null && added.length > 0) {
		int[]            indices = new int[added.length];

		for(int counter = 0; counter < added.length; counter++) {
		    indices[counter] = startIndex + counter;
		}
		getTreeModel().nodesWereInserted((TreeNode)element, indices);
	    }
        }
	if(!element.isLeaf()) {
	    int        startIndex = element.getElementIndex
		                       (event.getOffset());
	    int        elementCount = element.getElementCount();
	    int        endIndex = Math.min(elementCount - 1,
					   element.getElementIndex
				     (event.getOffset() + event.getLength()));

	    if(startIndex > 0 && startIndex < elementCount &&
	       element.getElement(startIndex).getStartOffset() ==
	       event.getOffset()) {
		// Force checking the previous element.
		startIndex--;
	    }
	    if(startIndex != -1 && endIndex != -1) {
		for(int counter = startIndex; counter <= endIndex; counter++) {
		    updateTree(event, element.getElement(counter));
		}
	    }
	}
	else {
	    // Element is a leaf, assume it changed
	    getTreeModel().nodeChanged((TreeNode)element);
	}
    }

    /**
     * Returns a TreePath to the element at <code>position</code>.
     */
    protected TreePath getPathForIndex(int position, Object root,
				       Element rootElement) {
	TreePath         path = new TreePath(root);
	Element          child = rootElement.getElement
	                            (rootElement.getElementIndex(position));

	path = path.pathByAddingChild(rootElement);
	path = path.pathByAddingChild(child);
	while(!child.isLeaf()) {
	    child = child.getElement(child.getElementIndex(position));
	    path = path.pathByAddingChild(child);
	}
	return path;
    }


    /**
     * ElementTreeModel is an implementation of TreeModel to handle displaying
     * the Elements from a Document. AbstractDocument.AbstractElement is
     * the default implementation used by the swing text package to implement
     * Element, and it implements TreeNode. This makes it trivial to create
     * a DefaultTreeModel rooted at a particular Element from the Document.
     * Unfortunately each Document can have more than one root Element.
     * Implying that to display all the root elements as a child of another
     * root a fake node has be created. This class creates a fake node as
     * the root with the children being the root elements of the Document
     * (getRootElements).
     * <p>This subclasses DefaultTreeModel. The majority of the TreeModel
     * methods have been subclassed, primarily to special case the root.
     */
    public static class ElementTreeModel extends DefaultTreeModel {
	protected Element[]         rootElements;

	public ElementTreeModel(Document document) {
	    super(new DefaultMutableTreeNode("root"), false);
	    rootElements = document.getRootElements();
	}

	/**
	 * Returns the child of <I>parent</I> at index <I>index</I> in
	 * the parent's child array.  <I>parent</I> must be a node
	 * previously obtained from this data source. This should
	 * not return null if <i>index</i> is a valid index for
	 * <i>parent</i> (that is <i>index</i> >= 0 && <i>index</i>
	 * < getChildCount(<i>parent</i>)).
	 *
	 * @param   parent  a node in the tree, obtained from this data source
	 * @return  the child of <I>parent</I> at index <I>index</I>
	 */
	public Object getChild(Object parent, int index) {
	    if(parent == root)
		return rootElements[index];
	    return super.getChild(parent, index);
	}


	/**
	 * Returns the number of children of <I>parent</I>.  Returns 0
	 * if the node is a leaf or if it has no children.
	 * <I>parent</I> must be a node previously obtained from this
	 * data source.
	 *
	 * @param   parent  a node in the tree, obtained from this data source
	 * @return  the number of children of the node <I>parent</I>
	 */
	public int getChildCount(Object parent) {
	    if(parent == root)
		return rootElements.length;
	    return super.getChildCount(parent);
	}


	/**
	 * Returns true if <I>node</I> is a leaf.  It is possible for
	 * this method to return false even if <I>node</I> has no
	 * children.  A directory in a filesystem, for example, may
	 * contain no files; the node representing the directory is
	 * not a leaf, but it also has no children.
	 *
	 * @param   node    a node in the tree, obtained from this data source
	 * @return  true if <I>node</I> is a leaf
	 */
	public boolean isLeaf(Object node) {
	    if(node == root)
		return false;
	    return super.isLeaf(node);
	}

	/**
	 * Returns the index of child in parent.
	 */
	public int getIndexOfChild(Object parent, Object child) {
	    if(parent == root) {
		for(int counter = rootElements.length - 1; counter >= 0;
		    counter--) {
		    if(rootElements[counter] == child)
			return counter;
		}
		return -1;
	    }
	    return super.getIndexOfChild(parent, child);
	}

	/**
	 * Invoke this method after you've changed how node is to be
	 * represented in the tree.
	 */
	public void nodeChanged(TreeNode node) {
	    if(listenerList != null && node != null) {
		TreeNode         parent = node.getParent();

		if(parent == null && node != root) {
		    parent = root;
		}
		if(parent != null) {
		    int        anIndex = getIndexOfChild(parent, node);

		    if(anIndex != -1) {
			int[]        cIndexs = new int[1];

			cIndexs[0] = anIndex;
			nodesChanged(parent, cIndexs);
		    }
		}
	    }
        }

	/**
	 * Returns the path to a particluar node. This is recursive.
	 */
	protected TreeNode[] getPathToRoot(TreeNode aNode, int depth) {
	    TreeNode[]              retNodes;

	    /* Check for null, in case someone passed in a null node, or
	       they passed in an element that isn't rooted at root. */
	    if(aNode == null) {
		if(depth == 0)
		    return null;
		else
		    retNodes = new TreeNode[depth];
	    }
	    else {
		depth++;
		if(aNode == root)
		    retNodes = new TreeNode[depth];
		else {
		    TreeNode parent = aNode.getParent();

		    if(parent == null)
			parent = root;
		    retNodes = getPathToRoot(parent, depth);
		}
		retNodes[retNodes.length - depth] = aNode;
	    }
	    return retNodes;
	}
    }
}