diff options
Diffstat (limited to 'libjava/javax/swing/tree/DefaultMutableTreeNode.java')
| -rw-r--r-- | libjava/javax/swing/tree/DefaultMutableTreeNode.java | 1017 |
1 files changed, 1017 insertions, 0 deletions
diff --git a/libjava/javax/swing/tree/DefaultMutableTreeNode.java b/libjava/javax/swing/tree/DefaultMutableTreeNode.java new file mode 100644 index 00000000000..288b0edc1c9 --- /dev/null +++ b/libjava/javax/swing/tree/DefaultMutableTreeNode.java @@ -0,0 +1,1017 @@ +/* DefaultMutableTreeNode.java -- + Copyright (C) 2002 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA +02111-1307 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package javax.swing.tree; + +// Imports +import java.io.*; +import java.util.*; + +/** + * DefaultMutableTreeNode + * @author Andrew Selkirk + */ +public class DefaultMutableTreeNode implements Cloneable, MutableTreeNode, Serializable { + + //------------------------------------------------------------- + // Variables -------------------------------------------------- + //------------------------------------------------------------- + + /** + * EMPTY_ENUMERATION + */ + public static final Enumeration EMPTY_ENUMERATION = null; // TODO + + /** + * parent + */ + protected MutableTreeNode parent = null; + + /** + * children + */ + protected Vector children = new Vector(); + + /** + * userObject + */ + protected transient Object userObject = ""; + + /** + * allowsChildren + */ + protected boolean allowsChildren = true; + + + //------------------------------------------------------------- + // Initialization --------------------------------------------- + //------------------------------------------------------------- + + /** + * Constructor DefaultMutableTreeNode + */ + public DefaultMutableTreeNode() { + // TODO + } // DefaultMutableTreeNode() + + /** + * Constructor DefaultMutableTreeNode + * @param value0 TODO + */ + public DefaultMutableTreeNode(Object userObject) { + this.userObject = userObject; + } // DefaultMutableTreeNode() + + /** + * Constructor DefaultMutableTreeNode + * @param value0 TODO + * @param value1 TODO + */ + public DefaultMutableTreeNode(Object userObject, boolean allowsChildren) { + this.userObject = userObject; + this.allowsChildren = allowsChildren; + } // DefaultMutableTreeNode() + + + //------------------------------------------------------------- + // Methods ---------------------------------------------------- + //------------------------------------------------------------- + + /** + * clone + * @returns Object + */ + public Object clone() { + return null; // TODO + } // clone() + + /** + * toString + * @returns String + */ + public String toString() { + if (userObject == null) { + return null; + } // if + return userObject.toString(); + } // toString() + + /** + * add + * @param value0 TODO + */ + public void add(MutableTreeNode child) { + children.add(child); + child.setParent(this); + } // add() + + /** + * getParent + * @returns TreeNode + */ + public TreeNode getParent() { + return parent; + } // getParent() + + /** + * remove + * @param value0 TODO + */ + public void remove(int index) { + children.remove(index); + } // remove() + + /** + * remove + * @param value0 TODO + */ + public void remove(MutableTreeNode node) { + children.remove(node); + } // remove() + + /** + * writeObject + * @param value0 TODO + * @exception IOException TODO + */ + private void writeObject(ObjectOutputStream value0) throws IOException { + // TODO + } // writeObject() + + /** + * readObject + * @param value0 TODO + * @exception IOException TODO + * @exception ClassNotFoundException TODO + */ + private void readObject(ObjectInputStream value0) throws IOException, ClassNotFoundException { + // TODO + } // readObject() + + /** + * insert + * @param value0 TODO + * @param value1 TODO + */ + public void insert(MutableTreeNode node, int index) { + children.insertElementAt(node, index); + } // insert() + + /** + * getPath + * @returns TreeNode[] + */ + public TreeNode[] getPath() { + + // Variables + TreeNode[] path; + int size; + int index; + TreeNode current; + + // Determine length of Path + size = getLevel() + 1; + + // Create Path + path = new TreeNode[size]; + current = this; + for (index = size - 1; index >= 0; index--) { + path[index] = current; + current = current.getParent(); + } // for + + // Return Path + return path; + + } // getPath() + + /** + * children + * @returns Enumeration + */ + public Enumeration children() { + return children.elements(); + } // children() + + /** + * setParent + * @param value0 TODO + */ + public void setParent(MutableTreeNode node) { + parent = node; + } // setParent() + + /** + * getChildAt + * @param value0 TODO + * @returns TreeNode + */ + public TreeNode getChildAt(int index) { + return (TreeNode) children.elementAt(index); + } // getChildAt() + + /** + * getChildCount + * @returns int + */ + public int getChildCount() { + return children.size(); + } // getChildCount() + + /** + * getIndex + * @param value0 TODO + * @returns int + */ + public int getIndex(TreeNode node) { + return children.indexOf(node); + } // getIndex() + + /** + * setAllowsChildren + * @param value0 TODO + */ + public void setAllowsChildren(boolean allowsChildren) { + this.allowsChildren = allowsChildren; + } // setAllowsChildren() + + /** + * getAllowsChildren + * @returns boolean + */ + public boolean getAllowsChildren() { + return allowsChildren; + } // getAllowsChildren() + + /** + * setUserObject + * @param value0 TODO + */ + public void setUserObject(Object userObject) { + this.userObject = userObject; + } // setUserObject() + + /** + * getUserObject + * @returns Object + */ + public Object getUserObject() { + return userObject; + } // getUserObject() + + /** + * removeFromParent + */ + public void removeFromParent() { + parent = null; + // TODO + } // removeFromParent() + + /** + * removeAllChildren + */ + public void removeAllChildren() { + children.removeAllElements(); + } // removeAllChildren() + + /** + * isNodeAncestor + * @param value0 TODO + * @returns boolean + */ + public boolean isNodeAncestor(TreeNode node) { + + // Variables + TreeNode current; + + // Sanity Check + if (node == null) { + return false; + } // if + + // Search For Ancestor + current = this; + while (current != null && current != node) { + current = current.getParent(); + } // while + + // Check for Ancestor + if (current == node) { + return true; + } // if + + // Otherwise, no + return false; + + } // isNodeAncestor() + + /** + * isNodeDescendant + * @param value0 TODO + * @returns boolean + */ + public boolean isNodeDescendant(DefaultMutableTreeNode node) { + + // Variables + TreeNode current; + + // Sanity Check + if (node == null) { + return false; + } // if + + // Search For Descendant + current = node; + while (current != null && current != this) { + current = current.getParent(); + } // while + + // Check for Descendant + if (current == this) { + return true; + } // if + + // Otherwise, no + return false; + + } // isNodeDescendant() + + /** + * getSharedAncestor + * @param value0 TODO + * @returns TreeNode + */ + public TreeNode getSharedAncestor(DefaultMutableTreeNode node) { + + // Variables + ArrayList list; + TreeNode current; + + // Get List of Path Elements for this node + current = this; + list = new ArrayList(); + while (current != null) { + list.add(current); + current = current.getParent(); + } // while + + // Check if any path element of node are in list + current = node; + while (current != null) { + if (list.contains(current) == true) { + return current; + } // if + current = current.getParent(); + } // while + + // Unable to locate shared ancestor + return null; + + } // getSharedAncestor() + + /** + * isNodeRelated + * @param value0 TODO + * @returns boolean + */ + public boolean isNodeRelated(DefaultMutableTreeNode node) { + + // Sanity Check + if (node == null) { + return false; + } // if + + // Check for the same root + if (node.getRoot() == getRoot()) { + return true; + } // if + + // Nodes are not related + return false; + + } // isNodeRelated() + + /** + * getDepth + * @returns int + */ + public int getDepth() { + + // Variables + TreeNode node; + int depth; + int current; + int size; + Stack stack; + int index; + + // Check for children + if (allowsChildren == false || children.size() == 0) { + return 0; + } // if + + // Process Depths + stack = new Stack(); + stack.push(new Integer(0)); + node = getChildAt(0); +//System.out.println(" * Descend: 0-0"); + depth = 0; + current = 1; + while (stack.empty() == false) { + + // Check if node has children + if (node.getChildCount() != 0) { + node = node.getChildAt(0); + stack.push(new Integer(0)); + current++; +// System.out.println(" * Descend: 0-" + current); + + // Check for next sibling + } else { + + // Check Depth + if (current > depth) { + depth = current; + } // if + + do { + + // Traverse to Parent + node = node.getParent(); + size = node.getChildCount(); + current--; + index = ((Integer) stack.pop()).intValue(); +// System.out.println(" * Ascend from: " + index + "-" + current); + index++; + + } while (index >= size && node != this); + + // Check for child + if (index < size) { + node = node.getChildAt(index); + stack.push(new Integer(index)); + current++; +// System.out.println(" * Descend: " + index + "-" + current); + } // if + + } // if + + } // while + + return depth; + + } // getDepth() + + static Random random = new Random(System.currentTimeMillis()); + + public static void growTree(DefaultMutableTreeNode root) { + + // Variables + int size; + int index; + DefaultMutableTreeNode node; + DefaultMutableTreeNode current; + + current = root; + index = 0; +// while (current != root) { + do { + +// if (random.nextInt(3) < 2) { + if (random.nextBoolean()) { + node = new DefaultMutableTreeNode(String.valueOf(index)); + index++; + current.add(node); + current = node; + } else { + current = (DefaultMutableTreeNode) current.getParent(); + } // if + +// } // while + } while (current != root && current != null); + + System.out.println("Number of nodes: " + index); + +/* + // Calc # children + size = random.nextInt(4); + + for (index = 0; index < size; index++) { + + // Create Node + node = new DefaultMutableTreeNode(String.valueOf(index)); + growTree(node); + + // Add Node to root + root.add(node); + + } // for +*/ + } // growTree() + + public static void main(String[] argv) { +/* + DefaultMutableTreeNode node1 = new DefaultMutableTreeNode("node1"); + DefaultMutableTreeNode node2 = new DefaultMutableTreeNode("node2"); + DefaultMutableTreeNode node3 = new DefaultMutableTreeNode("node3"); + DefaultMutableTreeNode node4 = new DefaultMutableTreeNode("node4"); + DefaultMutableTreeNode node5 = new DefaultMutableTreeNode("node5"); + DefaultMutableTreeNode node6 = new DefaultMutableTreeNode("node6"); + DefaultMutableTreeNode node7 = new DefaultMutableTreeNode("node7"); + DefaultMutableTreeNode node8 = new DefaultMutableTreeNode("node8"); + + node1.add(node2); + node1.add(node3); + node2.add(node4); + node2.add(node5); + node3.add(node6); + node3.add(node7); + node5.add(node8); + + System.out.println("Depth (node1): " + node1.getDepth()); + System.out.println("Depth (node2): " + node2.getDepth()); + System.out.println("Depth (node3): " + node3.getDepth()); +*/ + + System.out.println("Create tree..."); + DefaultMutableTreeNode root = new DefaultMutableTreeNode("root"); + growTree(root); + System.out.println("Find depth..."); + System.out.println("Depth (root): " + root.getDepth()); + + } // main + + /** + * getLevel + * @returns int + */ + public int getLevel() { + + // Variables + TreeNode current; + int count; + + // Lookup Parent + count = -1; + current = this; + do { + current = current.getParent(); + count++; + } while (current != null); + + return count; + + } // getLevel() + + /** + * getPathToRoot + * @param value0 TODO + * @param value1 TODO + * @returns TreeNode[] + */ + protected TreeNode[] getPathToRoot(TreeNode value0, int value1) { + return null; // TODO + } // getPathToRoot() + + /** + * getUserObjectPath + * @returns Object[] + */ + public Object[] getUserObjectPath() { + + // Variables + TreeNode[] path; + Object[] object; + int size; + int index; + + // Get Path for Tree Nodes + path = getPath(); + + // Construct Object Path + object = new Object[path.length]; + for (index = 0; index < path.length; index++) { + object[index] = ((DefaultMutableTreeNode) path[index]).getUserObject(); + } // for + + // Return Object Path + return object; + + } // getUserObjectPath() + + /** + * getRoot + * @returns TreeNode + */ + public TreeNode getRoot() { + + // Variables + TreeNode current; + TreeNode check; + + // Lookup Parent + current = this; + check = current.getParent(); + while (check != null) { + current = check; + check = current.getParent(); + } // while + + return current; + + } // getRoot() + + /** + * isRoot + * @returns boolean + */ + public boolean isRoot() { + return (parent == null); + } // isRoot() + + /** + * getNextNode + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getNextNode() { + return null; // TODO + } // getNextNode() + + /** + * getPreviousNode + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getPreviousNode() { + return null; // TODO + } // getPreviousNode() + + /** + * preorderEnumeration + * @returns Enumeration + */ + public Enumeration preorderEnumeration() { + return null; // TODO + } // preorderEnumeration() + + /** + * postorderEnumeration + * @returns Enumeration + */ + public Enumeration postorderEnumeration() { + return null; // TODO + } // postorderEnumeration() + + /** + * breadthFirstEnumeration + * @returns Enumeration + */ + public Enumeration breadthFirstEnumeration() { + return null; // TODO + } // breadthFirstEnumeration() + + /** + * depthFirstEnumeration + * @returns Enumeration + */ + public Enumeration depthFirstEnumeration() { + return null; // TODO + } // depthFirstEnumeration() + + /** + * pathFromAncestorEnumeration + * @param value0 TODO + * @returns Enumeration + */ + public Enumeration pathFromAncestorEnumeration(TreeNode value0) { + return null; // TODO + } // pathFromAncestorEnumeration() + + /** + * isNodeChild + * @param value0 TODO + * @returns boolean + */ + public boolean isNodeChild(TreeNode node) { + + // Variables + TreeNode current; + int index; + + // Sanity Check + if (node == null) { + return false; + } // if + + // Process Path + current = node; + while (current != null) { + if (current == this) { + return true; + } // if + current = current.getParent(); + } // while + + // Node not located in path, not child + return false; + + } // isNodeChild() + + /** + * getFirstChild + * @returns TreeNode + */ + public TreeNode getFirstChild() { + return (TreeNode) children.firstElement(); + } // getFirstChild() + + /** + * getLastChild + * @returns TreeNode + */ + public TreeNode getLastChild() { + return (TreeNode) children.lastElement(); + } // getLastChild() + + /** + * getChildAfter + * @param value0 TODO + * @returns TreeNode + */ + public TreeNode getChildAfter(TreeNode node) { + + // Variables + int index; + + // Check node + if (node == null || node.getParent() != this) { + throw new IllegalArgumentException(); + } // if + + // Get index of child node + index = getIndex(node); + + // Check for child after + index++; + if (index == getChildCount()) { + return null; + } // if + + // Retrieve Child After + return getChildAt(index); + + } // getChildAfter() + + /** + * getChildBefore + * @param value0 TODO + * @returns TreeNode + */ + public TreeNode getChildBefore(TreeNode node) { + + // Variables + int index; + + // Check node + if (node == null || node.getParent() != this) { + throw new IllegalArgumentException(); + } // if + + // Get index of child node + index = getIndex(node); + + // Check for child before + index--; + if (index < 0) { + return null; + } // if + + // Retrieve Child Before + return getChildAt(index); + + } // getChildBefore() + + /** + * isNodeSibling + * @param value0 TODO + * @returns boolean + */ + public boolean isNodeSibling(TreeNode node) { + + // Variables + int index; + + // Check for null + if (node == null) { + return false; + } // if + + // Check if nodes share a parent + if (node.getParent() == getParent() && getParent() != null) { + return true; + } // if + + // Nodes are not siblings + return false; + + } // isNodeSibling() + + /** + * getSiblingCount + * @returns int + */ + public int getSiblingCount() { + + // Variables + + // Check for no parent + if (parent == null) { + return 1; + } // if + + // Calculate sibling count from parent's child count + return parent.getChildCount(); + + } // getSiblingCount() + + /** + * getNextSibling + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getNextSibling() { + + // Variables + int index; + int size; + + // Check for Parent + if (parent == null) { + return null; + } // if + + // Get Index of this node + index = parent.getIndex(this); + + // Check for Next Sibling + size = parent.getChildCount(); + index++; + if (index == size) { + return null; + } // if + + return (DefaultMutableTreeNode) parent.getChildAt(index); + + } // getNextSibling() + + /** + * getPreviousSibling + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getPreviousSibling() { + + // Variables + int index; + + // Check for Parent + if (parent == null) { + return null; + } // if + + // Get Index of this node + index = parent.getIndex(this); + + // Check for Previous Sibling + index--; + if (index < 0) { + return null; + } // if + + return (DefaultMutableTreeNode) parent.getChildAt(index); + + } // getPreviousSibling() + + /** + * isLeaf + * @returns boolean + */ + public boolean isLeaf() { + return (children.size() == 0); // TODO: check allowsChildren?? + } // isLeaf() + + /** + * getFirstLeaf + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getFirstLeaf() { + + // Variables + TreeNode current; + + current = this; + while (current.getChildCount() > 0) { + current = current.getChildAt(0); + } // while + + return (DefaultMutableTreeNode) current; + + } // getFirstLeaf() + + /** + * getLastLeaf + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getLastLeaf() { + + // Variables + TreeNode current; + int size; + + current = this; + size = current.getChildCount(); + while (size > 0) { + current = current.getChildAt(size - 1); + size = current.getChildCount(); + } // while + + return (DefaultMutableTreeNode) current; + + } // getLastLeaf() + + /** + * getNextLeaf + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getNextLeaf() { + return null; // TODO + } // getNextLeaf() + + /** + * getPreviousLeaf + * @returns DefaultMutableTreeNode + */ + public DefaultMutableTreeNode getPreviousLeaf() { + return null; // TODO + } // getPreviousLeaf() + + /** + * getLeafCount + * @returns int + */ + public int getLeafCount() { + + // Variables + Enumeration enum; + int count; + TreeNode current; + + // Get Enumeration of all descendants + enum = depthFirstEnumeration(); + + // Process Nodes + count = 0; + while (enum.hasMoreElements() == true) { + current = (TreeNode) enum.nextElement(); + if (current.isLeaf() == true) { + count++; + } // if + } // if + + return count; + + } // getLeafCount() + + +} // DefaultMutableTreeNode |