1 files changed, 282 insertions, 0 deletions
diff --git a/NET/worlds/console/Tree.java b/NET/worlds/console/Tree.java
new file mode 100644
index 0000000..b6f6d0c
--- /dev/null
+++ b/NET/worlds/console/Tree.java
@@ -0,0 +1,282 @@
+package NET.worlds.console;
+
+import NET.worlds.scape.LibraryDropTarget;
+import java.util.Hashtable;
+import java.util.Vector;
+
+public class Tree extends TreePanel implements MainCallback, LibraryDropTarget {
+   private static final long serialVersionUID = -1919976160954835913L;
+   private int openItem = -1;
+   private int changeItem = -1;
+   private TreeCallback owner;
+   private boolean registered;
+
+   public Tree() {
+   }
+
+   public Tree(TreeCallback owner) {
+      this();
+      this.setOwner(owner);
+   }
+
+   public void setOwner(TreeCallback owner) {
+      this.owner = owner;
+   }
+
+   public void change(TreeNode root, Object current) {
+      this.delayRepaints(true);
+      this.removeAllElements();
+      this.addElement(root);
+      int index = this.search(0, current, new Hashtable<TreeNode, TreeNode>());
+
+      assert index != -1;
+
+      this.sync(index);
+   }
+
+   public void change(TreeNode root, Vector<TreeNode> lineage) {
+      this.delayRepaints(true);
+      this.removeAllElements();
+      TreeNode parent = root;
+      this.addElement(root);
+      int index = 1;
+
+      for (int j = 0; j < lineage.size(); j++) {
+         Object lookingFor = lineage.elementAt(j);
+         Vector<TreeNode> v = this.getSortedChildren(parent);
+         parent.setOpen(true);
+         int count = v.size();
+         int foundIndex = -1;
+
+         for (int i = 0; i < count; i++) {
+            TreeNode child = v.elementAt(i);
+            int tmp = index + i;
+            this.insertElementAt(child, tmp);
+            if (foundIndex == -1 && child.getObject().equals(lookingFor)) {
+               foundIndex = tmp;
+               parent = child;
+            }
+         }
+
+         assert foundIndex != -1;
+
+         index = foundIndex + 1;
+      }
+
+      this.sync(index - 1);
+   }
+
+   public void update() {
+      Vector<TreeNode> newTree = new Vector<TreeNode>();
+      int count = this.countElements();
+
+      for (int i = 0; i < count; i++) {
+         TreeNode e1 = this.elementAt(i);
+         if (e1.getParent() == null) {
+            newTree.addElement(e1);
+            this.recurseAddChildren(newTree, e1);
+         }
+      }
+
+      TreeNode selected = this.getSelectedNode();
+      count = newTree.size();
+      int ix = 0;
+
+      while (ix < count && !newTree.elementAt(ix).equals(selected)) {
+         ix++;
+      }
+
+      int hitem = ix < count ? ix : Math.min(count - 1, this.getSelectedIndex());
+      this.delayRepaints(true);
+      this.reset(newTree);
+      this.sync(hitem);
+   }
+
+   private void sync(int selected) {
+      try {
+         this.select(selected);
+         Object treeNode = this.getSelectedNode().getObject();
+         if (treeNode != null) {
+            this.owner.treeChange(treeNode);
+            this.delayRepaints(false);
+         }
+      } catch (Exception var3) {
+      }
+   }
+
+   private Vector<TreeNode> getSortedChildren(TreeNode parent) {
+      Vector<TreeNode> unsorted = (Vector<TreeNode>)parent.getChildren();
+      Vector<TreeNode> sorted = new Vector<TreeNode>(unsorted.size());
+      if (unsorted != null) {
+         int icount = unsorted.size();
+
+         for (int i = 0; i < icount; i++) {
+            TreeNode e = unsorted.elementAt(i);
+            if (!parent.shouldSort()) {
+               sorted.insertElementAt(e, i);
+            } else {
+               int jcount = sorted.size();
+               int j = 0;
+
+               while (j < jcount && sorted.elementAt(j).toString().compareTo(e.toString()) <= 0) {
+                  j++;
+               }
+
+               sorted.insertElementAt(e, j);
+            }
+         }
+      }
+
+      return sorted;
+   }
+
+   private Vector<TreeNode> getCurrentChildren(TreeNode parent) {
+      Vector<TreeNode> ret = new Vector<TreeNode>();
+      int count = this.countElements();
+
+      for (int i = 0; i < count; i++) {
+         TreeNode ele = this.elementAt(i);
+         if (ele.getParent() == parent) {
+            ret.addElement(ele);
+         }
+      }
+
+      return ret;
+   }
+
+   private static TreeNode maybeUseOldChild(TreeNode newChild, Vector<TreeNode> oldChildren) {
+      int count = oldChildren.size();
+
+      for (int i = 0; i < count; i++) {
+         TreeNode oldChild = oldChildren.elementAt(i);
+         if (oldChild.equals(newChild)) {
+            return oldChild;
+         }
+      }
+
+      return newChild;
+   }
+
+   private void recurseAddChildren(Vector<TreeNode> newTree, TreeNode oldEle) {
+      if (oldEle.isOpen()) {
+         Vector<TreeNode> oldChildren = this.getCurrentChildren(oldEle);
+         Vector<TreeNode> newChildren = this.getSortedChildren(oldEle);
+         int count = newChildren.size();
+
+         for (int i = 0; i < count; i++) {
+            TreeNode child = newChildren.elementAt(i);
+            child = maybeUseOldChild(child, oldChildren);
+            newTree.addElement(child);
+            this.recurseAddChildren(newTree, child);
+         }
+      }
+   }
+
+   private int search(int index, Object obj, Hashtable<TreeNode, TreeNode> lookedAt) {
+      TreeNode e = this.elementAt(index);
+      if (e.getObject().equals(obj)) {
+         return index;
+      } else {
+         if (!lookedAt.containsKey(e)) {
+            lookedAt.put(e, e);
+            index++;
+            Vector<TreeNode> v = this.getSortedChildren(e);
+            e.setOpen(true);
+            if (v != null) {
+               int count = v.size();
+
+               for (int i = 0; i < count; i++) {
+                  this.insertElementAt(v.elementAt(i), index + i);
+               }
+
+               for (int i = 0; i < count; i++) {
+                  int found = this.search(index + i, obj, lookedAt);
+                  if (found != -1) {
+                     return found;
+                  }
+               }
+
+               for (int ix = 0; ix < count; ix++) {
+                  this.removeElementAt(index);
+               }
+            }
+
+            e.setOpen(false);
+         }
+
+         return -1;
+      }
+   }
+
+   private void register() {
+      if (!this.registered) {
+         Main.register(this);
+         this.registered = true;
+      }
+   }
+
+   @Override
+   public void treeSelect(int item) {
+      if (item != this.getSelectedIndex()) {
+         this.select(item);
+         this.changeItem = item;
+         this.register();
+      }
+   }
+
+   @Override
+   public void treeOpen(int item) {
+      if (this.openItem == -1) {
+         this.openItem = item;
+         this.register();
+      }
+   }
+
+   @Override
+   public void setFocus(boolean hasFocus) {
+      boolean hadFocus = this.hasFocus();
+      super.setFocus(hasFocus);
+      if (hadFocus != hasFocus) {
+         this.owner.treeFocusChanged(hasFocus);
+      }
+   }
+
+   @Override
+   public synchronized void mainCallback() {
+      this.delayRepaints(true);
+      int i = this.changeItem;
+      this.changeItem = -1;
+      if (i != -1) {
+         this.owner.treeChange(this.elementAt(i).getObject());
+      }
+
+      i = this.openItem;
+      this.openItem = -1;
+      if (i != -1) {
+         TreeNode e = this.elementAt(i);
+         boolean isOpen = !e.isOpen();
+         e.setOpen(isOpen);
+         i++;
+         if (isOpen) {
+            Vector<TreeNode> v = this.getSortedChildren(e);
+            if (v != null) {
+               int count = v.size();
+
+               for (int j = 0; j < count; j++) {
+                  this.insertElementAt(v.elementAt(j), i++);
+               }
+            }
+         } else {
+            while (i < this.countElements() && e.isDescendant(this.elementAt(i))) {
+               this.removeElementAt(i);
+            }
+         }
+
+         this.repaint();
+      }
+
+      this.delayRepaints(false);
+      this.registered = false;
+      Main.unregister(this);
+   }
+}