KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > prefuse > util > ui > JPrefuseTree


1 package prefuse.util.ui;
2
3 import javax.swing.JFrame JavaDoc;
4 import javax.swing.JScrollPane JavaDoc;
5 import javax.swing.JTree JavaDoc;
6 import javax.swing.event.TreeModelEvent JavaDoc;
7 import javax.swing.event.TreeModelListener JavaDoc;
8 import javax.swing.tree.TreeModel JavaDoc;
9 import javax.swing.tree.TreePath JavaDoc;
10
11 import prefuse.data.Graph;
12 import prefuse.data.Node;
13 import prefuse.data.Tree;
14 import prefuse.data.event.EventConstants;
15 import prefuse.data.event.GraphListener;
16 import prefuse.util.StringLib;
17 import prefuse.util.collections.CopyOnWriteArrayList;
18 import prefuse.visual.VisualTree;
19
20 /**
21  * Swing component that displays a prefuse Tree instance in a Swing
22  * JTree component. Graph instances can also be displayed by first
23  * getting a Tree instance with the
24  * {@link prefuse.data.Graph#getSpanningTree()} method.
25  *
26  * @author <a HREF="http://jheer.org">jeffrey heer</a>
27  * @see javax.swing.JTree
28  */

29 public class JPrefuseTree extends JTree JavaDoc {
30
31     private Tree JavaDoc m_tree;
32     private String JavaDoc m_field;
33     
34     /**
35      * Create a new JPrefuseTree.
36      * @param t the Tree to display
37      * @param labelField the data field used to privde labels
38      */

39     public JPrefuseTree(Tree JavaDoc t, String JavaDoc labelField) {
40         super();
41         m_tree = t;
42         m_field = labelField;
43         
44         PrefuseTreeModel model = new PrefuseTreeModel();
45         super.setModel(model);
46         m_tree.addGraphModelListener(model);
47     }
48     
49     /**
50      * Return the backing Tree instance.
51      * @return the backing Tree
52      */

53     public Tree JavaDoc getTree() {
54         return m_tree;
55     }
56     
57     /**
58      * Returns a String label for Node instances by looking up the
59      * label data field specified in the constructor of this class.
60      * @see javax.swing.JTree#convertValueToText(java.lang.Object, boolean, boolean, boolean, int, boolean)
61      */

62     public String JavaDoc convertValueToText(Object JavaDoc value, boolean selected,
63             boolean expanded, boolean leaf, int row, boolean hasFocus)
64     {
65         if ( value == null )
66             return "";
67         
68         if ( value instanceof Node ) {
69             Object JavaDoc o = ((Node)value).get(m_field);
70             if ( o.getClass().isArray() ) {
71                 return StringLib.getArrayString(o);
72             } else {
73                 return o.toString();
74             }
75         } else {
76             return value.toString();
77         }
78     }
79     
80     // ------------------------------------------------------------------------
81

82     /**
83      * TreeModel implementation that provides an adapter to a backing prefuse
84      * Tree instance.
85      */

86     public class PrefuseTreeModel implements TreeModel JavaDoc, GraphListener {
87
88         private CopyOnWriteArrayList m_listeners = new CopyOnWriteArrayList();
89         
90         /**
91          * @see javax.swing.tree.TreeModel#getRoot()
92          */

93         public Object JavaDoc getRoot() {
94             return m_tree.getRoot();
95         }
96
97         /**
98          * @see javax.swing.tree.TreeModel#getChild(java.lang.Object, int)
99          */

100         public Object JavaDoc getChild(Object JavaDoc node, int idx) {
101             Node c = ((Node)node).getChild(idx);
102             if ( c == null ) {
103                 throw new IllegalArgumentException JavaDoc("Index out of range: "+idx);
104             }
105             return c;
106         }
107
108         /**
109          * @see javax.swing.tree.TreeModel#getChildCount(java.lang.Object)
110          */

111         public int getChildCount(Object JavaDoc node) {
112             return ((Node)node).getChildCount();
113         }
114
115         /**
116          * @see javax.swing.tree.TreeModel#isLeaf(java.lang.Object)
117          */

118         public boolean isLeaf(Object JavaDoc node) {
119             return ((Node)node).getChildCount() == 0;
120         }
121
122         /**
123          * @see javax.swing.tree.TreeModel#valueForPathChanged(javax.swing.tree.TreePath, java.lang.Object)
124          */

125         public void valueForPathChanged(TreePath JavaDoc path, Object JavaDoc newValue) {
126             // do nothing?
127
}
128
129         /**
130          * @see javax.swing.tree.TreeModel#getIndexOfChild(java.lang.Object, java.lang.Object)
131          */

132         public int getIndexOfChild(Object JavaDoc parent, Object JavaDoc child) {
133             return ((Node)parent).getChildIndex(((Node)child));
134         }
135
136         /**
137          * @see javax.swing.tree.TreeModel#addTreeModelListener(javax.swing.event.TreeModelListener)
138          */

139         public void addTreeModelListener(TreeModelListener JavaDoc tml) {
140             if ( !m_listeners.contains(tml) )
141                 m_listeners.add(tml);
142         }
143
144         /**
145          * @see javax.swing.tree.TreeModel#removeTreeModelListener(javax.swing.event.TreeModelListener)
146          */

147         public void removeTreeModelListener(TreeModelListener JavaDoc tml) {
148             m_listeners.remove(tml);
149         }
150
151         /**
152          * @see prefuse.data.event.GraphListener#graphChanged(prefuse.data.Graph, java.lang.String, int, int, int, int)
153          */

154         public void graphChanged(Graph g, String JavaDoc table, int start, int end,
155                                  int col, int type)
156         {
157             if ( m_listeners == null || m_listeners.size() == 0 )
158                 return; // nothing to do
159

160             boolean nodeTable = table.equals(Graph.NODES);
161             if ( type != EventConstants.UPDATE && nodeTable )
162                 return;
163             else if ( type == EventConstants.UPDATE && !nodeTable )
164                 return;
165             
166             for ( int row = start; row <= end; ++row ) {
167                 // create the event
168
Node n = null;
169                 if ( nodeTable )
170                     n = g.getNode(row);
171                 else
172                     n = g.getEdge(row).getTargetNode();
173                 Object JavaDoc[] path = new Object JavaDoc[n.getDepth()+1];
174                 for ( int i=path.length; --i>=0; n=n.getParent() ) {
175                     path[i] = n;
176                 }
177                 TreeModelEvent JavaDoc e = new TreeModelEvent JavaDoc(this, path);
178                 
179                 // fire it
180
Object JavaDoc[] lstnrs = m_listeners.getArray();
181                 for ( int i=0; i<lstnrs.length; ++i ) {
182                     TreeModelListener JavaDoc tml = (TreeModelListener JavaDoc)lstnrs[i];
183                     
184                     switch ( type ) {
185                     case EventConstants.INSERT:
186                         tml.treeNodesInserted(e);
187                         break;
188                     case EventConstants.DELETE:
189                         tml.treeNodesRemoved(e);
190                         break;
191                     case EventConstants.UPDATE:
192                         tml.treeNodesChanged(e);
193                     }
194                 }
195             }
196         }
197                 
198     } // end of inner class PrefuseTreeModel
199

200     // ------------------------------------------------------------------------
201

202     /**
203      * Create a new window displaying the contents of the input Tree as
204      * a Swing JTree.
205      * @param t the Tree instance to display
206      * @param labelField the data field to use for labeling nodes
207      * @return a reference to the JFrame holding the tree view
208      */

209     public static JFrame JavaDoc showTreeWindow(Tree JavaDoc t, String JavaDoc labelField) {
210         JPrefuseTree tree = new JPrefuseTree(t, labelField);
211         String JavaDoc title = t.toString();
212         if ( t instanceof VisualTree ) {
213             title = ((VisualTree)t).getGroup() + " " + title;
214         }
215         JFrame JavaDoc frame = new JFrame JavaDoc(title);
216         frame.getContentPane().add(new JScrollPane JavaDoc(tree));
217         frame.pack();
218         frame.setVisible(true);
219         return frame;
220     }
221     
222 } // end of class JPrefuseTree
223
Popular Tags