1 /*
2 * $Id$
3 *
4 * Copyright (c) 2001, 2009, Oracle and/or its affiliates. All rights reserved.
5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 *
7 * This code is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 only, as
9 * published by the Free Software Foundation. Oracle designates this
10 * particular file as subject to the "Classpath" exception as provided
11 * by Oracle in the LICENSE file that accompanied this code.
12 *
13 * This code is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * version 2 for more details (a copy is included in the LICENSE file that
17 * accompanied this code).
18 *
19 * You should have received a copy of the GNU General Public License version
20 * 2 along with this work; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
22 *
23 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
24 * or visit www.oracle.com if you need additional information or have any
25 * questions.
26 */
27 package com.sun.javatest.exec;
28
29 import java.awt.EventQueue;
30 import java.util.Enumeration;
31
32 import javax.swing.JTree;
33 import javax.swing.ToolTipManager;
34 import javax.swing.event.TreeModelEvent;
35 import javax.swing.event.TreeModelListener;
36 import javax.swing.tree.TreeModel;
37 import javax.swing.tree.TreePath;
38
39 import com.sun.javatest.Parameters;
40 import com.sun.javatest.TestFilter;
41 import com.sun.javatest.TestResult;
42 import com.sun.javatest.TestResultTable;
43 import com.sun.javatest.tool.UIFactory;
44 import com.sun.javatest.util.Debug;
45 import com.sun.javatest.util.DynamicArray;
46 import javax.swing.tree.TreeSelectionModel;
47
48 /**
49 * Tree to render test structure.
50 */
51 class TestTree extends JTree {
52 /**
53 * @param uif The UI factory object to use.
54 * @param model The GUI model object.
55 * @param fConfig The active filter configuration object.
56 * @param treeModel The data model.
57 */
58 public TestTree(UIFactory uif, TreePanelModel model, FilterSelectionHandler fh,
59 TestTreeModel treeModel) {
60 super();
61
62 this.uif = uif;
63 this.tpm = model;
64 this.filterHandler = fh;
65
66 filterHandler.addObserver(watcher);
67
68 //currModel = new TestTreeModel(null);
69 currModel = treeModel;
70 setModel(currModel);
71 setLargeModel(true);
72 setScrollsOnExpand(true);
73 setName("tree");
74 ToolTipManager.sharedInstance().registerComponent(this);
75 }
76
77 /**
78 * Call when it is likely that the Parameters or filters have changed internally.
79 */
80 public void updateGUI() {
81 // delete this if the model becomes top-level
82
83 // invalidate the node info cache because we don't know what part
84 // of the parameters have changed. A filter change is likely if
85 // the user has just completed an interview
86 repaint();
87 }
88
89 public void setModel(TreeModel newModel) {
90 super.setModel(newModel);
91 newModel.addTreeModelListener(watcher);
92 }
93
94 // ---------- private ----------
95 void setParameters(Parameters p) {
96 // this is only here to notify the model when we change things which
97 // affect the tree structure itself.
98 // otherwise, most changes are the result of filter changes
99 }
100
101 /**
102 * For proper operation, this method is recommended over the method on JTree.
103 *
104 * @param mod The new data model.
105 */
106 void setTreeModel(TestTreeModel mod) {
107 if (currModel != null)
108 currModel.removeTreeModelListener(watcher);
109
110 currModel = mod;
111 setModel(currModel);
112 }
113
114 TestResultTable getTestResultTable() {
115 // remove this method when the model becomes independent
116 return currModel.getTestResultTable();
117 }
118
119 TreePath[] snapshotSelectedPaths() {
120
121 TreeSelectionModel tsm = getSelectionModel();
122 if (tsm == null) return null;
123
124 return tsm.getSelectionPaths();
125
126 }
127
128 void restoreSelection(String[] selectedUrls) {
129 if (selectedUrls == null || selectedUrls.length == 0)
130 return;
131
132 if (currModel instanceof TestTreeModel) {
133 final TreePath[] paths = currModel.urlsToPaths(selectedUrls);
134
135 if (!EventQueue.isDispatchThread()) {
136 EventQueue.invokeLater(new Runnable() {
137 @Override
138 public void run() {
139 restoreSelection(paths);
140 }
141
142 });
143 }
144 else
145 restoreSelection(paths);
146 }
147 }
148
149 private void restoreSelection(TreePath[] selectedPaths) {
150 if (selectedPaths == null || selectedPaths.length == 0)
151 return;
152
153 TreeSelectionModel tsm = getSelectionModel();
154 if (tsm == null)
155 return;
156
157 // add or set ???
158 tsm.addSelectionPaths(selectedPaths);
159 }
160
161
162 /**
163 * Record which tree nodes are currently visible.
164 * @see #restorePaths
165 */
166 TreePath[] snapshotOpenPaths() {
167 // currModel.getRoot()==null may indicate that the GUI has been
168 // disposed already (?). We have seen exceptions in the code
169 // below because this situation occurs.
170 if (currModel == null || currModel.getRoot() == null)
171 return null;
172
173 TreePath[] paths = new TreePath[0];
174 Enumeration e = getDescendantToggledPaths(new TreePath(currModel.getRoot()));
175
176 while (e != null && e.hasMoreElements()) {
177 TreePath tp = (TreePath)(e.nextElement());
178 if (!isVisible(tp)) // if we can't see it, we don't care
179 continue;
180 if (!isExpanded(tp)) // if it's not expanded, we don't need it
181 continue;
182
183 paths = DynamicArray.append(paths, tp);
184 } // while
185
186 return paths;
187 }
188
189 /**
190 * Restore open paths in the tree. Should be called on the event thread.
191 * @param openUrls The path urls to restore.
192 * @param queue True if the request should be put into the event queue at the
193 * end - this can be important for proper queuing of operations.
194 */
195 void restorePaths(final String[] openUrls, boolean queue) {
196 if (openUrls == null || openUrls.length == 0)
197 return;
198
199 if (currModel instanceof TestTreeModel) {
200 final TreePath[] paths = currModel.urlsToPaths(openUrls);
201
202 if (!EventQueue.isDispatchThread() || queue) {
203 EventQueue.invokeLater(new Runnable() {
204 public void run() {
205 restorePaths(paths);
206 }
207 });
208 }
209 else
210 restorePaths(paths);
211 }
212 }
213
214 /**
215 * Attempt to restore paths which were previously recorded.
216 * @see #snapshotOpenPaths
217 */
218 void restorePaths(TreePath[] paths) {
219 // make sure root still matches
220 if (paths == null || paths.length == 0)
221 return;
222
223 for (int i = 0; i < paths.length; i++) {
224 if (paths[i].getPathCount() == 1)
225 continue;
226
227 //expandPath(paths[i]);
228 setExpandedState(paths[i], true);
229 makeVisible(paths[i]);
230 } // for
231 }
232
233 private UIFactory uif;
234 private TestTreeModel currModel;
235 private TreePanelModel tpm;
236 private FilterSelectionHandler filterHandler;
237 private EventWatcher watcher = new EventWatcher();
238
239 //protected static boolean debug = boolean.getboolean("debug." + testtree.class.getname());
240 private static int debug = Debug.getInt("debug." + TestTree.class.getName());
241
242 private class EventWatcher implements TreeModelListener, FilterSelectionHandler.Observer {
243 // TreeModelListener - on event thread
244 public void treeNodesChanged(TreeModelEvent e) {
245 // NOTE: cannot get selected item from tree because if it has
246 // been replaced already, there may be nothing selected
247 String activeTest = tpm.getSelectedTest();
248 if (activeTest == null) {
249 return;
250 }
251
252 Object[] targets = e.getChildren();
253 if (targets == null)
254 return; // don't care then
255
256 for (int i = 0; i < targets.length; i++)
257 if (targets[i] instanceof TT_TestNode) {
258 TestResult tr = ((TT_TestNode)targets[i]).getTestResult();
259
260 if (tr.getTestName().equals(activeTest))
261 tpm.showTest(tr);
262 }
263
264 repaint();
265 }
266
267 public void treeNodesInserted(TreeModelEvent e) {
268 // NOTE: cannot get selected item from tree because if it has
269 // been replaced already, there may be nothing selected
270 String activeTest = tpm.getSelectedTest();
271 if (activeTest == null) {
272 return;
273 }
274
275 Object[] targets = e.getChildren();
276 if (targets == null)
277 return; // don't care then
278
279 for (int i = 0; i < targets.length; i++)
280 if (targets[i] instanceof TT_TestNode) {
281 TestResult tr = ((TT_TestNode)targets[i]).getTestResult();
282
283 if (tr.getTestName().equals(activeTest))
284 tpm.showTest(tr);
285 }
286 }
287
288 public void treeNodesRemoved(TreeModelEvent e) {
289 // XXX need to handle case when shown node is removed
290 // select root in that case?
291 }
292
293 public void treeStructureChanged(TreeModelEvent e) {
294 TreePath[] tp = snapshotOpenPaths();
295
296 TreePath[] selected = snapshotSelectedPaths();
297
298 //tpm.showNode(getModel().getRoot(), new TreePath(getModel().getRoot()));
299
300 if (tp != null && tp.length != 0)
301 restorePaths(tp);
302
303 restoreSelection(selected);
304 }
305
306 // FilterConfig.Observer - may not be on event thread
307 public void filterUpdated(TestFilter f) {
308 updateGUI();
309 }
310
311 public void filterSelected(TestFilter f) {
312 updateGUI();
313 }
314
315 public void filterAdded(TestFilter f) {
316 // don't care
317 }
318
319 public void filterRemoved(TestFilter f) {
320 // don't care
321 }
322
323 }
324 }