Java tutorial
/** * Class: TreeUtil * Description: A simple utility class for dealing with Trees * @author Le Cuong Nguyen **/ //package atnf.atoms.mon.util; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Hashtable; import java.util.StringTokenizer; import javax.swing.JMenu; import javax.swing.JMenuItem; import javax.swing.JTree; import javax.swing.event.EventListenerList; import javax.swing.event.TreeSelectionEvent; import javax.swing.event.TreeSelectionListener; import javax.swing.tree.DefaultMutableTreeNode; import javax.swing.tree.TreeNode; import javax.swing.tree.TreePath; public class TreeUtil implements ActionListener, TreeSelectionListener { protected DefaultMutableTreeNode itsRootNode = null; protected JMenuItem itsRootMenu = null; // Should really do this with an object encompassing the nodes and data // with only on map. But this is easier... protected Hashtable<String, Object> itsMap = new Hashtable<String, Object>(); protected Hashtable<String, Object> itsTreeMap = new Hashtable<String, Object>(); public static final int TREE = 7654; public static final int MENU = 7655; // Want to do stuff with ActionListeners private EventListenerList itsListeners = new EventListenerList(); public TreeUtil(String name, Object root) { itsMap.put(name, root); itsRootNode = new DefaultMutableTreeNode(name); itsTreeMap.put(name, itsRootNode); } public TreeUtil(String name) { itsMap.put(name, new Object()); itsRootNode = new DefaultMutableTreeNode(name); itsTreeMap.put(name, itsRootNode); } public void addNode(String name) { addNode(name, new Object()); } public void addNode(String name, Object obj) { itsMap.put(name, obj); DefaultMutableTreeNode tempNode = itsRootNode; StringTokenizer tok = new StringTokenizer(name, "."); String currentName = null; while (tok.hasMoreTokens()) { String myTok = tok.nextToken(); currentName = (currentName == null) ? myTok : currentName + "." + myTok; boolean createNew = true; for (int j = 0; j < tempNode.getChildCount(); j++) { DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) tempNode.getChildAt(j); if (childNode.toString().equals(myTok)) { tempNode = childNode; createNew = false; break; } } if (createNew) { DefaultMutableTreeNode aNode = new DefaultMutableTreeNode(myTok); itsTreeMap.put(currentName, aNode); // Let's give some consideration to where in the tree we place // the new node. // We want any nodes with children to be listed first, in // alphabetical order. // Then come nodes with no children, in alphabetical order. if (tok.hasMoreTokens()) { // This node is not a leaf node int targeti; for (targeti = 0; targeti < tempNode.getChildCount(); targeti++) { TreeNode bNode = tempNode.getChildAt(targeti); if (bNode.isLeaf() || bNode.toString().compareToIgnoreCase(myTok) > 0) { break; } } tempNode.insert(aNode, targeti); } else { // This node is a leaf node int targeti; for (targeti = 0; targeti < tempNode.getChildCount(); targeti++) { TreeNode bNode = tempNode.getChildAt(targeti); if (bNode.isLeaf() && bNode.toString().compareToIgnoreCase(myTok) > 0) { break; } } tempNode.insert(aNode, targeti); } tempNode = aNode; } } } public void addChildNode(DefaultMutableTreeNode parent, String name) { String realName = parent.getUserObject().toString() + "." + name; addNode(realName); } public Object getNodeObject(String name) { return itsMap.get(name); } public void setNodeObject(String node, Object data) { itsMap.put(node, data); } public String[] getAllNodes() { return toStringArray(itsMap.keySet().toArray()); } public static String[] toStringArray(Object[] data) { String[] res = new String[data.length]; for (int i = 0; i < res.length; i++) { res[i] = (String) (data[i]); } return res; } public DefaultMutableTreeNode getNode(String name) { return (DefaultMutableTreeNode) itsTreeMap.get(name); } public DefaultMutableTreeNode getRootNode() { return itsRootNode; } /** * Make a Menu structure, without the root node. The children of the root * node will be added to the specified menu element. */ public void getMenus(JMenu menu) { int numChild = itsRootNode.getChildCount(); for (int i = 0; i < numChild; i++) { menu.add(getMenus((DefaultMutableTreeNode) itsRootNode.getChildAt(i), menu)); } } /** * Makes menus from the root node */ public JMenuItem getMenus() { JMenu rootMenu = new JMenu(itsRootNode.getUserObject().toString()); rootMenu.setActionCommand("TreeMenu"); rootMenu.addActionListener(this); return getMenus(itsRootNode, rootMenu); } /** Creates the menus by using recursion */ public JMenuItem getMenus(DefaultMutableTreeNode node, JMenu parentMenu) { String name = node.getUserObject().toString(); int numChild = node.getChildCount(); if (numChild < 1) { JMenuItem tempMenu = new JMenuItem(name); tempMenu.setActionCommand(parentMenu.getActionCommand() + "." + name); tempMenu.addActionListener(this); return tempMenu; } JMenu tempMenu = new JMenu(name); tempMenu.setActionCommand(parentMenu.getActionCommand() + "." + name); tempMenu.addActionListener(this); for (int i = 0; i < numChild; i++) { tempMenu.add(getMenus((DefaultMutableTreeNode) node.getChildAt(i), tempMenu)); } return tempMenu; } public JTree getTree() { return getTree(itsRootNode); } public JTree getTree(DefaultMutableTreeNode node) { JTree tree = new JTree(node); // tree.addTreeSelectionListener(this); return tree; } public void addActionListener(ActionListener listener) { itsListeners.add(ActionListener.class, listener); } public void removeActionListener(ActionListener listener) { itsListeners.remove(ActionListener.class, listener); } public void fireActionEvent(ActionEvent ae) { Object[] listeners = itsListeners.getListenerList(); for (int i = 0; i < listeners.length; i += 2) { if (listeners[i] == ActionListener.class) { ((ActionListener) listeners[i + 1]).actionPerformed(ae); } } } public void actionPerformed(ActionEvent e) { String cmd = e.getActionCommand(); int idx = cmd.indexOf('.'); cmd = cmd.substring(++idx, cmd.length()); fireActionEvent(new ActionEvent(this, MENU, cmd)); } public void valueChanged(TreeSelectionEvent e) { TreePath path = e.getPath(); Object[] items = path.getPath(); if (items.length < 1) { return; } String cmd = ""; for (int i = 0; i < items.length; i++) { cmd = cmd + "." + items[i].toString(); } if (cmd.length() > 0) { cmd = cmd.substring(1); } fireActionEvent(new ActionEvent(this, TREE, cmd)); } /* * public ArrayList search(String pattern) { ArrayList res = new * ArrayList(); try { RE re = new RE(pattern, RE.MATCH_CASEINDEPENDENT); * Iterator it = itsTreeMap.keySet().iterator(); while (it.hasNext()) { * String key = (String)it.next(); if (re.match(key)) res.add(key); } } * catch (Exception e) {e.printStackTrace();} return res; } */ public TreePath makeTreePath(String path) { return makeTreePath(path, itsRootNode); } public static TreePath makeTreePath(String path, DefaultMutableTreeNode parentNode) { DefaultMutableTreeNode tempNode = parentNode; TreePath res = new TreePath(parentNode); StringTokenizer tok = new StringTokenizer(path, "."); String currentPath = null; while (tok.hasMoreTokens()) { String myTok = tok.nextToken(); currentPath = (currentPath == null) ? myTok : currentPath + "." + myTok; for (int j = 0; j < tempNode.getChildCount(); j++) { DefaultMutableTreeNode childNode = (DefaultMutableTreeNode) tempNode.getChildAt(j); if (childNode.toString().equals(myTok)) { tempNode = childNode; res = res.pathByAddingChild(tempNode); break; } } } return res; } public static String pathToString(TreePath path) { if (path == null) { return null; } Object[] obj = path.getPath(); String res = ""; for (int i = 0; i < obj.length; i++) { res = res + "." + obj[i].toString(); } if (res.length() > 0) { res = res.substring(1); } return res; } }