1018 lines
20 KiB
Java
1018 lines
20 KiB
Java
/* 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
|