1:
37:
38: package ;
39:
40: import ;
41: import ;
42: import ;
43: import ;
44: import ;
45: import ;
46: import ;
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55:
56: import ;
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63: import ;
64: import ;
65: import ;
66: import ;
67: import ;
68: import ;
69: import ;
70: import ;
71: import ;
72: import ;
73: import ;
74: import ;
75: import ;
76: import ;
77: import ;
78: import ;
79: import ;
80: import ;
81: import ;
82: import ;
83: import ;
84: import ;
85:
86: public class JTree extends JComponent implements Scrollable, Accessible
87: {
88:
89:
94: protected class AccessibleJTree extends JComponent.AccessibleJComponent
95: implements AccessibleSelection, TreeSelectionListener, TreeModelListener,
96: TreeExpansionListener
97: {
98:
99:
103: protected class AccessibleJTreeNode extends AccessibleContext
104: implements Accessible, AccessibleComponent, AccessibleSelection,
105: AccessibleAction
106: {
107:
108: private JTree tree;
109: private TreePath tp;
110: private Accessible acc;
111: private AccessibleStateSet states;
112: private Vector selectionList;
113: private Vector actionList;
114: private TreeModel mod;
115: private Cursor cursor;
116:
117:
124: public AccessibleJTreeNode(JTree t, TreePath p, Accessible ap)
125: {
126: states = new AccessibleStateSet();
127: selectionList = new Vector();
128: actionList = new Vector();
129: mod = tree.getModel();
130: cursor = JTree.this.getCursor();
131:
132: tree = t;
133: tp = p;
134: acc = ap;
135:
136:
137:
138: TreePath[] selected = tree.getSelectionPaths();
139: for (int i = 0; i < selected.length; i++)
140: {
141: TreePath sel = selected[i];
142: if ((sel.getParentPath()).equals(tp))
143: selectionList.add(sel);
144: }
145:
146:
147:
148: actionList.add("EXPAND");
149: actionList.add("COLLAPSE");
150: actionList.add("EDIT");
151: actionList.add("SELECT");
152: actionList.add("DESELECT");
153: }
154:
155:
161: public void addAccessibleSelection(int i)
162: {
163: if (mod != null)
164: {
165: Object child = mod.getChild(tp.getLastPathComponent(), i);
166: if (child != null)
167: {
168: if (!states.contains(AccessibleState.MULTISELECTABLE))
169: clearAccessibleSelection();
170: selectionList.add(child);
171: tree.addSelectionPath(tp.pathByAddingChild(child));
172: }
173: }
174: }
175:
176:
182: public void addFocusListener(FocusListener l)
183: {
184: tree.addFocusListener(l);
185: }
186:
187:
192: public void addPropertyChangeListener(PropertyChangeListener l)
193: {
194:
195: }
196:
197:
201: public void clearAccessibleSelection()
202: {
203: selectionList.clear();
204: }
205:
206:
214: public boolean contains(Point p)
215: {
216: return getBounds().contains(p);
217: }
218:
219:
225: public boolean doAccessibleAction(int i)
226: {
227: if (i >= actionList.size() || i < 0)
228: return false;
229:
230: if (actionList.get(i).equals("EXPAND"))
231: tree.expandPath(tp);
232: else if (actionList.get(i).equals("COLLAPSE"))
233: tree.collapsePath(tp);
234: else if (actionList.get(i).equals("SELECT"))
235: tree.addSelectionPath(tp);
236: else if (actionList.get(i).equals("DESELECT"))
237: tree.removeSelectionPath(tp);
238: else if (actionList.get(i).equals("EDIT"))
239: tree.startEditingAtPath(tp);
240: else
241: return false;
242: return true;
243: }
244:
245:
250: public AccessibleAction getAccessibleAction()
251: {
252: return this;
253: }
254:
255:
260: public int getAccessibleActionCount()
261: {
262: return actionList.size();
263: }
264:
265:
271: public String getAccessibleActionDescription(int i)
272: {
273: if (i < 0 || i >= actionList.size())
274: return (actionList.get(i)).toString();
275: return super.getAccessibleDescription();
276: }
277:
278:
285: public Accessible getAccessibleAt(Point p)
286: {
287: TreePath acc = tree.getClosestPathForLocation(p.x, p.y);
288: if (acc != null)
289: return new AccessibleJTreeNode(tree, acc, this);
290: return null;
291: }
292:
293:
299: public Accessible getAccessibleChild(int i)
300: {
301: if (mod != null)
302: {
303: Object child = mod.getChild(tp.getLastPathComponent(), i);
304: if (child != null)
305: return new AccessibleJTreeNode(tree, tp.pathByAddingChild(child),
306: acc);
307: }
308: return null;
309: }
310:
311:
316: public int getAccessibleChildrenCount()
317: {
318: TreeModel mod = getModel();
319: if (mod != null)
320: return mod.getChildCount(tp.getLastPathComponent());
321: return 0;
322: }
323:
324:
329: public AccessibleComponent getAccessibleComponent()
330: {
331: return this;
332: }
333:
334:
339: public AccessibleContext getAccessibleContext()
340: {
341: return this;
342: }
343:
344:
349: public String getAccessibleDescription()
350: {
351: return super.getAccessibleDescription();
352: }
353:
354:
359: public int getAccessibleIndexInParent()
360: {
361: AccessibleContext parent = getAccessibleParent().getAccessibleContext();
362: if (parent != null)
363: for (int i = 0; i < parent.getAccessibleChildrenCount(); i++)
364: {
365: if ((parent.getAccessibleChild(i)).equals(this))
366: return i;
367: }
368: return -1;
369: }
370:
371:
376: public String getAccessibleName()
377: {
378: return super.getAccessibleName();
379: }
380:
381:
386: public Accessible getAccessibleParent()
387: {
388: return super.getAccessibleParent();
389: }
390:
391:
396: public AccessibleRole getAccessibleRole()
397: {
398: return AccessibleJTree.this.getAccessibleRole();
399: }
400:
401:
406: public AccessibleSelection getAccessibleSelection()
407: {
408: return this;
409: }
410:
411:
417: public Accessible getAccessibleSelection(int i)
418: {
419: if (i > 0 && i < getAccessibleSelectionCount())
420: return new AccessibleJTreeNode(tree,
421: tp.pathByAddingChild(selectionList.get(i)), acc);
422: return null;
423: }
424:
425:
430: public int getAccessibleSelectionCount()
431: {
432: return selectionList.size();
433: }
434:
435:
440: public AccessibleStateSet getAccessibleStateSet()
441: {
442: if (isVisible())
443: states.add(AccessibleState.VISIBLE);
444: if (tree.isCollapsed(tp))
445: states.add(AccessibleState.COLLAPSED);
446: if (tree.isEditable())
447: states.add(AccessibleState.EDITABLE);
448: if (mod != null &&
449: !mod.isLeaf(tp.getLastPathComponent()))
450: states.add(AccessibleState.EXPANDABLE);
451: if (tree.isExpanded(tp))
452: states.add(AccessibleState.EXPANDED);
453: if (isFocusable())
454: states.add(AccessibleState.FOCUSABLE);
455: if (hasFocus())
456: states.add(AccessibleState.FOCUSED);
457: if (tree.getSelectionModel().getSelectionMode() !=
458: TreeSelectionModel.SINGLE_TREE_SELECTION)
459: states.add(AccessibleState.MULTISELECTABLE);
460: if (tree.isOpaque())
461: states.add(AccessibleState.OPAQUE);
462: if (tree.isPathSelected(tp))
463: states.add(AccessibleState.SELECTED);
464: if (isShowing())
465: states.add(AccessibleState.SHOWING);
466:
467: states.add(AccessibleState.SELECTABLE);
468: return states;
469: }
470:
471:
476: public AccessibleText getAccessibleText()
477: {
478: return super.getAccessibleText();
479: }
480:
481:
486: public AccessibleValue getAccessibleValue()
487: {
488: return super.getAccessibleValue();
489: }
490:
491:
496: public Color getBackground()
497: {
498: return tree.getBackground();
499: }
500:
501:
506: public Rectangle getBounds()
507: {
508: return tree.getPathBounds(tp);
509: }
510:
511:
516: public Cursor getCursor()
517: {
518: return cursor;
519: }
520:
521:
526: public Font getFont()
527: {
528: return tree.getFont();
529: }
530:
531:
537: public FontMetrics getFontMetrics(Font f)
538: {
539: return tree.getFontMetrics(f);
540: }
541:
542:
547: public Color getForeground()
548: {
549: return tree.getForeground();
550: }
551:
552:
557: public Locale getLocale()
558: {
559: return tree.getLocale();
560: }
561:
562:
569: public Point getLocation()
570: {
571: return getLocationInJTree();
572: }
573:
574:
579: protected Point getLocationInJTree()
580: {
581: Rectangle bounds = tree.getPathBounds(tp);
582: return new Point(bounds.x, bounds.y);
583: }
584:
585:
590: public Point getLocationOnScreen()
591: {
592: Point loc = getLocation();
593: SwingUtilities.convertPointToScreen(loc, tree);
594: return loc;
595: }
596:
597:
602: public Dimension getSize()
603: {
604: Rectangle b = getBounds();
605: return b.getSize();
606: }
607:
608:
614: public boolean isAccessibleChildSelected(int i)
615: {
616: Object child = mod.getChild(tp.getLastPathComponent(), i);
617: if (child != null)
618: return tree.isPathSelected(tp.pathByAddingChild(child));
619: return false;
620: }
621:
622:
627: public boolean isEnabled()
628: {
629: return tree.isEnabled();
630: }
631:
632:
637: public boolean isFocusTraversable()
638: {
639: return true;
640: }
641:
642:
648: public boolean isShowing()
649: {
650: return isVisible() && tree.isShowing();
651: }
652:
653:
658: public boolean isVisible()
659: {
660: return tree.isVisible(tp);
661: }
662:
663:
669: public void removeAccessibleSelection(int i)
670: {
671: if (mod != null)
672: {
673: Object child = mod.getChild(tp.getLastPathComponent(), i);
674: if (child != null)
675: {
676: if (!states.contains(AccessibleState.MULTISELECTABLE))
677: clearAccessibleSelection();
678: if (selectionList.contains(child))
679: {
680: selectionList.remove(child);
681: tree.removeSelectionPath(tp.pathByAddingChild(child));
682: }
683: }
684: }
685: }
686:
687:
693: public void removeFocusListener(FocusListener l)
694: {
695: tree.removeFocusListener(l);
696: }
697:
698:
703: public void removePropertyChangeListener(PropertyChangeListener l)
704: {
705:
706: }
707:
708:
711: public void requestFocus()
712: {
713: tree.requestFocus();
714: }
715:
716:
720: public void selectAllAccessibleSelection()
721: {
722: Object parent = tp.getLastPathComponent();
723: if (mod != null)
724: {
725: for (int i = 0; i < mod.getChildCount(parent); i++)
726: {
727: Object child = mod.getChild(parent, i);
728: if (child != null)
729: {
730: if (!states.contains(AccessibleState.MULTISELECTABLE))
731: clearAccessibleSelection();
732: if (selectionList.contains(child))
733: {
734: selectionList.add(child);
735: tree.addSelectionPath(tp.pathByAddingChild(child));
736: }
737: }
738: }
739: }
740: }
741:
742:
747: public void setAccessibleDescription(String s)
748: {
749: super.setAccessibleDescription(s);
750: }
751:
752:
757: public void setAccessibleName(String s)
758: {
759: super.setAccessibleName(s);
760: }
761:
762:
767: public void setBackground(Color c)
768: {
769:
770: }
771:
772:
777: public void setBounds(Rectangle r)
778: {
779:
780: }
781:
782:
787: public void setCursor(Cursor c)
788: {
789: cursor = c;
790: }
791:
792:
797: public void setEnabled(boolean b)
798: {
799:
800: }
801:
802:
807: public void setFont(Font f)
808: {
809:
810: }
811:
812:
817: public void setForeground(Color c)
818: {
819:
820: }
821:
822:
827: public void setLocation(Point p)
828: {
829:
830: }
831:
832:
837: public void setSize(Dimension d)
838: {
839:
840: }
841:
842:
847: public void setVisible(boolean b)
848: {
849:
850: }
851: }
852:
853:
856: public AccessibleJTree()
857: {
858:
859: }
860:
861:
866: public void addAccessibleSelection(int i)
867: {
868: addSelectionInterval(i, i);
869: }
870:
871:
874: public void clearAccessibleSelection()
875: {
876: clearSelection();
877: }
878:
879:
882: public void fireVisibleDataPropertyChange()
883: {
884: treeDidChange();
885: }
886:
887:
894: public Accessible getAccessibleAt(Point p)
895: {
896: TreePath tp = getClosestPathForLocation(p.x, p.y);
897: if (tp != null)
898: return new AccessibleJTreeNode(JTree.this, tp, null);
899: return null;
900: }
901:
902:
908: public Accessible getAccessibleChild(int i)
909: {
910: return null;
911: }
912:
913:
918: public int getAccessibleChildrenCount()
919: {
920: TreeModel model = getModel();
921: if (model != null)
922: return model.getChildCount(model.getRoot());
923: return 0;
924: }
925:
926:
931: public int getAccessibleIndexInParent()
932: {
933: return 0;
934: }
935:
936:
941: public AccessibleRole getAccessibleRole()
942: {
943: return AccessibleRole.TREE;
944: }
945:
946:
951: public AccessibleSelection getAccessibleSelection()
952: {
953: TreeModel mod = getModel();
954: if (mod != null)
955: return (new AccessibleJTreeNode(JTree.this,
956: new TreePath(mod.getRoot()), null)).getAccessibleSelection();
957: return null;
958: }
959:
960:
965: public Accessible getAccessibleSelection(int i)
966: {
967: TreeModel mod = getModel();
968: if (mod != null)
969: return (new AccessibleJTreeNode(JTree.this,
970: new TreePath(mod.getRoot()), null)).getAccessibleSelection(i);
971: return null;
972: }
973:
974:
979: public int getAccessibleSelectionCount()
980: {
981: return getSelectionCount();
982: }
983:
984:
990: public boolean isAccessibleChildSelected(int i)
991: {
992:
993: return false;
994: }
995:
996:
1002: public void removeAccessibleSelection(int i)
1003: {
1004: removeSelectionInterval(i, i);
1005: }
1006:
1007:
1011: public void selectAllAccessibleSelection()
1012: {
1013: if (getSelectionModel().getSelectionMode() !=
1014: TreeSelectionModel.SINGLE_TREE_SELECTION)
1015: addSelectionInterval(0, getVisibleRowCount());
1016: }
1017:
1018:
1023: public void treeCollapsed(TreeExpansionEvent e)
1024: {
1025: fireTreeCollapsed(e.getPath());
1026: }
1027:
1028:
1033: public void treeExpanded(TreeExpansionEvent e)
1034: {
1035: fireTreeExpanded(e.getPath());
1036: }
1037:
1038:
1043: public void treeNodesChanged(TreeModelEvent e)
1044: {
1045:
1046: }
1047:
1048:
1053: public void treeNodesInserted(TreeModelEvent e)
1054: {
1055:
1056: }
1057:
1058:
1063: public void treeNodesRemoved(TreeModelEvent e)
1064: {
1065:
1066: }
1067:
1068:
1073: public void treeStructureChanged(TreeModelEvent e)
1074: {
1075:
1076: }
1077:
1078:
1083: public void valueChanged(TreeSelectionEvent e)
1084: {
1085: fireValueChanged(e);
1086: }
1087: }
1088:
1089: public static class DynamicUtilTreeNode extends DefaultMutableTreeNode
1090: {
1091: protected Object childValue;
1092:
1093: protected boolean loadedChildren;
1094:
1095:
1099: protected boolean hasChildren;
1100:
1101: public DynamicUtilTreeNode(Object value, Object children)
1102: {
1103: super(value);
1104: childValue = children;
1105: loadedChildren = false;
1106: }
1107:
1108: public int getChildCount()
1109: {
1110: loadChildren();
1111: return super.getChildCount();
1112: }
1113:
1114: protected void loadChildren()
1115: {
1116: if (!loadedChildren)
1117: {
1118: createChildren(this, childValue);
1119: loadedChildren = true;
1120: }
1121: }
1122:
1123: public Enumeration children()
1124: {
1125: loadChildren();
1126: return super.children();
1127: }
1128:
1129:
1137: public TreeNode getChildAt(int pos)
1138: {
1139: loadChildren();
1140: return super.getChildAt(pos);
1141: }
1142:
1143: public boolean isLeaf()
1144: {
1145: return (childValue == null || !(childValue instanceof Hashtable
1146: || childValue instanceof Vector || childValue.getClass()
1147: .isArray()));
1148: }
1149:
1150: public static void createChildren(DefaultMutableTreeNode parent,
1151: Object children)
1152: {
1153: if (children instanceof Hashtable)
1154: {
1155: Hashtable tab = (Hashtable) children;
1156: Enumeration e = tab.keys();
1157: while (e.hasMoreElements())
1158: {
1159: Object key = e.nextElement();
1160: Object val = tab.get(key);
1161: parent.add(new DynamicUtilTreeNode(key, val));
1162: }
1163: }
1164: else if (children instanceof Vector)
1165: {
1166: Iterator i = ((Vector) children).iterator();
1167: while (i.hasNext())
1168: {
1169: Object n = i.next();
1170: parent.add(new DynamicUtilTreeNode(n, n));
1171: }
1172: }
1173: else if (children != null && children.getClass().isArray())
1174: {
1175: Object[] arr = (Object[]) children;
1176: for (int i = 0; i < arr.length; ++i)
1177: parent.add(new DynamicUtilTreeNode(arr[i], arr[i]));
1178: }
1179: }
1180: }
1181:
1182:
1186: protected class TreeModelHandler implements TreeModelListener
1187: {
1188:
1189:
1192: protected TreeModelHandler()
1193: {
1194:
1195: }
1196:
1197:
1207: public void treeNodesChanged(TreeModelEvent ev)
1208: {
1209:
1210: }
1211:
1212:
1219: public void treeNodesInserted(TreeModelEvent ev)
1220: {
1221:
1222: }
1223:
1224:
1231: public void treeNodesRemoved(TreeModelEvent ev)
1232: {
1233:
1234:
1235: }
1236:
1237:
1244: public void treeStructureChanged(TreeModelEvent ev)
1245: {
1246:
1247: TreePath path = ev.getTreePath();
1248: setExpandedState(path, isExpanded(path));
1249: }
1250: }
1251:
1252:
1258: protected class TreeSelectionRedirector implements TreeSelectionListener,
1259: Serializable
1260: {
1261:
1262: private static final long serialVersionUID = -3505069663646241664L;
1263:
1264:
1267: protected TreeSelectionRedirector()
1268: {
1269:
1270: }
1271:
1272:
1277: public void valueChanged(TreeSelectionEvent ev)
1278: {
1279: TreeSelectionEvent rewritten =
1280: (TreeSelectionEvent) ev.cloneWithSource(JTree.this);
1281: fireValueChanged(rewritten);
1282: JTree.this.repaint();
1283: }
1284: }
1285:
1286:
1289: protected static class EmptySelectionModel extends DefaultTreeSelectionModel
1290: {
1291:
1292: private static final long serialVersionUID = -5815023306225701477L;
1293:
1294:
1297: protected static final EmptySelectionModel sharedInstance =
1298: new EmptySelectionModel();
1299:
1300:
1303: protected EmptySelectionModel()
1304: {
1305:
1306: }
1307:
1308:
1313: public static EmptySelectionModel sharedInstance()
1314: {
1315: return sharedInstance;
1316: }
1317:
1318:
1323: public void setSelectionPaths(TreePath[] paths)
1324: {
1325:
1326: }
1327:
1328:
1333: public void addSelectionPaths(TreePath[] paths)
1334: {
1335:
1336: }
1337:
1338:
1343: public void removeSelectionPaths(TreePath[] paths)
1344: {
1345:
1346: }
1347: }
1348:
1349: private static final long serialVersionUID = 7559816092864483649L;
1350:
1351: public static final String CELL_EDITOR_PROPERTY = "cellEditor";
1352:
1353: public static final String CELL_RENDERER_PROPERTY = "cellRenderer";
1354:
1355: public static final String EDITABLE_PROPERTY = "editable";
1356:
1357: public static final String INVOKES_STOP_CELL_EDITING_PROPERTY =
1358: "invokesStopCellEditing";
1359:
1360: public static final String LARGE_MODEL_PROPERTY = "largeModel";
1361:
1362: public static final String ROOT_VISIBLE_PROPERTY = "rootVisible";
1363:
1364: public static final String ROW_HEIGHT_PROPERTY = "rowHeight";
1365:
1366: public static final String SCROLLS_ON_EXPAND_PROPERTY = "scrollsOnExpand";
1367:
1368: public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
1369:
1370: public static final String SHOWS_ROOT_HANDLES_PROPERTY = "showsRootHandles";
1371:
1372: public static final String TOGGLE_CLICK_COUNT_PROPERTY = "toggleClickCount";
1373:
1374: public static final String TREE_MODEL_PROPERTY = "model";
1375:
1376: public static final String VISIBLE_ROW_COUNT_PROPERTY = "visibleRowCount";
1377:
1378:
1379: public static final String ANCHOR_SELECTION_PATH_PROPERTY =
1380: "anchorSelectionPath";
1381:
1382:
1383: public static final String LEAD_SELECTION_PATH_PROPERTY = "leadSelectionPath";
1384:
1385:
1386: public static final String EXPANDS_SELECTED_PATHS_PROPERTY =
1387: "expandsSelectedPaths";
1388:
1389: private static final Object EXPANDED = new Object();
1390:
1391: private static final Object COLLAPSED = new Object();
1392:
1393: private boolean dragEnabled;
1394:
1395: private boolean expandsSelectedPaths;
1396:
1397: private TreePath anchorSelectionPath;
1398:
1399: private TreePath leadSelectionPath;
1400:
1401:
1406: private Hashtable nodeStates = new Hashtable();
1407:
1408: protected transient TreeCellEditor cellEditor;
1409:
1410: protected transient TreeCellRenderer cellRenderer;
1411:
1412: protected boolean editable;
1413:
1414: protected boolean invokesStopCellEditing;
1415:
1416: protected boolean largeModel;
1417:
1418: protected boolean rootVisible;
1419:
1420: protected int rowHeight;
1421:
1422: protected boolean scrollsOnExpand;
1423:
1424: protected transient TreeSelectionModel selectionModel;
1425:
1426: protected boolean showsRootHandles;
1427:
1428: protected int toggleClickCount;
1429:
1430: protected transient TreeModel treeModel;
1431:
1432: protected int visibleRowCount;
1433:
1434:
1437: protected transient TreeModelListener treeModelListener;
1438:
1439:
1442: protected TreeSelectionRedirector selectionRedirector =
1443: new TreeSelectionRedirector();
1444:
1445:
1448: public JTree()
1449: {
1450: this(createTreeModel(null));
1451: }
1452:
1453:
1458: public JTree(Hashtable value)
1459: {
1460: this(createTreeModel(value));
1461: }
1462:
1463:
1468: public JTree(Object[] value)
1469: {
1470: this(createTreeModel(value));
1471: }
1472:
1473:
1478: public JTree(TreeModel model)
1479: {
1480: updateUI();
1481: setRootVisible(true);
1482: setModel(model);
1483: setSelectionModel(new EmptySelectionModel());
1484: selectionModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
1485: }
1486:
1487:
1492: public JTree(TreeNode root)
1493: {
1494: this(root, false);
1495: }
1496:
1497:
1505: public JTree(TreeNode root, boolean asksAllowChildren)
1506: {
1507: this(new DefaultTreeModel(root, asksAllowChildren));
1508: }
1509:
1510:
1515: public JTree(Vector value)
1516: {
1517: this(createTreeModel(value));
1518: }
1519:
1520: public int getRowForPath(TreePath path)
1521: {
1522: TreeUI ui = getUI();
1523:
1524: if (ui != null)
1525: return ui.getRowForPath(this, path);
1526:
1527: return -1;
1528: }
1529:
1530: public TreePath getPathForRow(int row)
1531: {
1532: TreeUI ui = getUI();
1533: return ui != null ? ui.getPathForRow(this, row) : null;
1534: }
1535:
1536: protected TreePath[] getPathBetweenRows(int index0, int index1)
1537: {
1538: TreeUI ui = getUI();
1539:
1540: if (ui == null)
1541: return null;
1542:
1543: int minIndex = Math.min(index0, index1);
1544: int maxIndex = Math.max(index0, index1);
1545: TreePath[] paths = new TreePath[maxIndex - minIndex + 1];
1546:
1547: for (int i = minIndex; i <= maxIndex; ++i)
1548: paths[i - minIndex] = ui.getPathForRow(this, i);
1549:
1550: return paths;
1551: }
1552:
1553:
1558: protected static TreeModel createTreeModel(Object value)
1559: {
1560: return new DefaultTreeModel(new DynamicUtilTreeNode(value, value));
1561: }
1562:
1563:
1568: public TreeUI getUI()
1569: {
1570: return (TreeUI) ui;
1571: }
1572:
1573:
1578: public void setUI(TreeUI ui)
1579: {
1580: super.setUI(ui);
1581: }
1582:
1583:
1586: public void updateUI()
1587: {
1588: setUI((TreeUI) UIManager.getUI(this));
1589: }
1590:
1591:
1596: public String getUIClassID()
1597: {
1598: return "TreeUI";
1599: }
1600:
1601:
1607: public AccessibleContext getAccessibleContext()
1608: {
1609: return new AccessibleJTree();
1610: }
1611:
1612:
1617: public Dimension getPreferredScrollableViewportSize()
1618: {
1619: return new Dimension (getPreferredSize().width, getVisibleRowCount()*getRowHeight());
1620: }
1621:
1622: public int getScrollableUnitIncrement(Rectangle visibleRect,
1623: int orientation, int direction)
1624: {
1625: return 1;
1626: }
1627:
1628: public int getScrollableBlockIncrement(Rectangle visibleRect,
1629: int orientation, int direction)
1630: {
1631: return 1;
1632: }
1633:
1634: public boolean getScrollableTracksViewportHeight()
1635: {
1636: if (getParent() instanceof JViewport)
1637: return ((JViewport) getParent()).getHeight() > getPreferredSize().height;
1638: return false;
1639: }
1640:
1641: public boolean getScrollableTracksViewportWidth()
1642: {
1643: if (getParent() instanceof JViewport)
1644: return ((JViewport) getParent()).getWidth() > getPreferredSize().width;
1645: return false;
1646: }
1647:
1648:
1653: public void addTreeExpansionListener(TreeExpansionListener listener)
1654: {
1655: listenerList.add(TreeExpansionListener.class, listener);
1656: }
1657:
1658:
1663: public void removeTreeExpansionListener(TreeExpansionListener listener)
1664: {
1665: listenerList.remove(TreeExpansionListener.class, listener);
1666: }
1667:
1668:
1673: public TreeExpansionListener[] getTreeExpansionListeners()
1674: {
1675: return (TreeExpansionListener[]) getListeners(TreeExpansionListener.class);
1676: }
1677:
1678:
1683: public void fireTreeCollapsed(TreePath path)
1684: {
1685: TreeExpansionEvent event = new TreeExpansionEvent(this, path);
1686: TreeExpansionListener[] listeners = getTreeExpansionListeners();
1687:
1688: for (int index = 0; index < listeners.length; ++index)
1689: listeners[index].treeCollapsed(event);
1690: }
1691:
1692:
1697: public void fireTreeExpanded(TreePath path)
1698: {
1699: TreeExpansionEvent event = new TreeExpansionEvent(this, path);
1700: TreeExpansionListener[] listeners = getTreeExpansionListeners();
1701:
1702: for (int index = 0; index < listeners.length; ++index)
1703: listeners[index].treeExpanded(event);
1704: }
1705:
1706:
1711: public void addTreeSelectionListener(TreeSelectionListener listener)
1712: {
1713: listenerList.add(TreeSelectionListener.class, listener);
1714: }
1715:
1716:
1721: public void removeTreeSelectionListener(TreeSelectionListener listener)
1722: {
1723: listenerList.remove(TreeSelectionListener.class, listener);
1724: }
1725:
1726:
1731: public TreeSelectionListener[] getTreeSelectionListeners()
1732: {
1733: return (TreeSelectionListener[])
1734: getListeners(TreeSelectionListener.class);
1735: }
1736:
1737:
1742: protected void fireValueChanged(TreeSelectionEvent event)
1743: {
1744: TreeSelectionListener[] listeners = getTreeSelectionListeners();
1745:
1746: for (int index = 0; index < listeners.length; ++index)
1747: listeners[index].valueChanged(event);
1748: }
1749:
1750:
1755: public void addTreeWillExpandListener(TreeWillExpandListener listener)
1756: {
1757: listenerList.add(TreeWillExpandListener.class, listener);
1758: }
1759:
1760:
1765: public void removeTreeWillExpandListener(TreeWillExpandListener listener)
1766: {
1767: listenerList.remove(TreeWillExpandListener.class, listener);
1768: }
1769:
1770:
1775: public TreeWillExpandListener[] getTreeWillExpandListeners()
1776: {
1777: return (TreeWillExpandListener[])
1778: getListeners(TreeWillExpandListener.class);
1779: }
1780:
1781:
1786: public void fireTreeWillCollapse(TreePath path) throws ExpandVetoException
1787: {
1788: TreeExpansionEvent event = new TreeExpansionEvent(this, path);
1789: TreeWillExpandListener[] listeners = getTreeWillExpandListeners();
1790:
1791: for (int index = 0; index < listeners.length; ++index)
1792: listeners[index].treeWillCollapse(event);
1793: }
1794:
1795:
1800: public void fireTreeWillExpand(TreePath path) throws ExpandVetoException
1801: {
1802: TreeExpansionEvent event = new TreeExpansionEvent(this, path);
1803: TreeWillExpandListener[] listeners = getTreeWillExpandListeners();
1804:
1805: for (int index = 0; index < listeners.length; ++index)
1806: listeners[index].treeWillExpand(event);
1807: }
1808:
1809:
1814: public TreeModel getModel()
1815: {
1816: return treeModel;
1817: }
1818:
1819:
1824: public void setModel(TreeModel model)
1825: {
1826: if (treeModel == model)
1827: return;
1828:
1829:
1830: if (treeModelListener == null)
1831: treeModelListener = createTreeModelListener();
1832: if (model != null)
1833: model.addTreeModelListener(treeModelListener);
1834:
1835: TreeModel oldValue = treeModel;
1836: treeModel = model;
1837:
1838: firePropertyChange(TREE_MODEL_PROPERTY, oldValue, model);
1839: updateUI();
1840: }
1841:
1842:
1848: public boolean isEditable()
1849: {
1850: return editable;
1851: }
1852:
1853:
1859: public void setEditable(boolean flag)
1860: {
1861: if (editable == flag)
1862: return;
1863:
1864: boolean oldValue = editable;
1865: editable = flag;
1866: firePropertyChange(EDITABLE_PROPERTY, oldValue, editable);
1867: }
1868:
1869:
1875: public boolean isRootVisible()
1876: {
1877: return rootVisible;
1878: }
1879:
1880: public void setRootVisible(boolean flag)
1881: {
1882: if (rootVisible == flag)
1883: return;
1884:
1885: boolean oldValue = rootVisible;
1886: rootVisible = flag;
1887: firePropertyChange(ROOT_VISIBLE_PROPERTY, oldValue, flag);
1888: }
1889:
1890: public boolean getShowsRootHandles()
1891: {
1892: return showsRootHandles;
1893: }
1894:
1895: public void setShowsRootHandles(boolean flag)
1896: {
1897: if (showsRootHandles == flag)
1898: return;
1899:
1900: boolean oldValue = showsRootHandles;
1901: showsRootHandles = flag;
1902: firePropertyChange(SHOWS_ROOT_HANDLES_PROPERTY, oldValue, flag);
1903: }
1904:
1905: public TreeCellEditor getCellEditor()
1906: {
1907: return cellEditor;
1908: }
1909:
1910: public void setCellEditor(TreeCellEditor editor)
1911: {
1912: if (cellEditor == editor)
1913: return;
1914:
1915: TreeCellEditor oldValue = cellEditor;
1916: cellEditor = editor;
1917: firePropertyChange(CELL_EDITOR_PROPERTY, oldValue, editor);
1918: }
1919:
1920: public TreeCellRenderer getCellRenderer()
1921: {
1922: return cellRenderer;
1923: }
1924:
1925: public void setCellRenderer(TreeCellRenderer newRenderer)
1926: {
1927: if (cellRenderer == newRenderer)
1928: return;
1929:
1930: TreeCellRenderer oldValue = cellRenderer;
1931: cellRenderer = newRenderer;
1932: firePropertyChange(CELL_RENDERER_PROPERTY, oldValue, newRenderer);
1933: }
1934:
1935: public TreeSelectionModel getSelectionModel()
1936: {
1937: return selectionModel;
1938: }
1939:
1940: public void setSelectionModel(TreeSelectionModel model)
1941: {
1942: if (selectionModel == model)
1943: return;
1944:
1945: if (selectionModel != null)
1946: selectionModel.removeTreeSelectionListener(selectionRedirector);
1947:
1948: TreeSelectionModel oldValue = selectionModel;
1949: selectionModel = model;
1950:
1951: if (selectionModel != null)
1952: selectionModel.addTreeSelectionListener(selectionRedirector);
1953:
1954: firePropertyChange(SELECTION_MODEL_PROPERTY, oldValue, model);
1955: revalidate();
1956: repaint();
1957: }
1958:
1959: public int getVisibleRowCount()
1960: {
1961: return visibleRowCount;
1962: }
1963:
1964: public void setVisibleRowCount(int rows)
1965: {
1966: if (visibleRowCount == rows)
1967: return;
1968:
1969: int oldValue = visibleRowCount;
1970: visibleRowCount = rows;
1971: firePropertyChange(VISIBLE_ROW_COUNT_PROPERTY, oldValue, rows);
1972: }
1973:
1974: public boolean isLargeModel()
1975: {
1976: return largeModel;
1977: }
1978:
1979: public void setLargeModel(boolean large)
1980: {
1981: if (largeModel == large)
1982: return;
1983:
1984: boolean oldValue = largeModel;
1985: largeModel = large;
1986: firePropertyChange(LARGE_MODEL_PROPERTY, oldValue, large);
1987: }
1988:
1989: public int getRowHeight()
1990: {
1991: return rowHeight;
1992: }
1993:
1994: public void setRowHeight(int height)
1995: {
1996: if (rowHeight == height)
1997: return;
1998:
1999: int oldValue = rowHeight;
2000: rowHeight = height;
2001: firePropertyChange(ROW_HEIGHT_PROPERTY, oldValue, height);
2002: }
2003:
2004: public boolean isFixedRowHeight()
2005: {
2006: return rowHeight > 0;
2007: }
2008:
2009: public boolean getInvokesStopCellEditing()
2010: {
2011: return invokesStopCellEditing;
2012: }
2013:
2014: public void setInvokesStopCellEditing(boolean invoke)
2015: {
2016: if (invokesStopCellEditing == invoke)
2017: return;
2018:
2019: boolean oldValue = invokesStopCellEditing;
2020: invokesStopCellEditing = invoke;
2021: firePropertyChange(INVOKES_STOP_CELL_EDITING_PROPERTY,
2022: oldValue, invoke);
2023: }
2024:
2025:
2028: public int getToggleClickCount()
2029: {
2030: return toggleClickCount;
2031: }
2032:
2033:
2036: public void setToggleClickCount(int count)
2037: {
2038: if (toggleClickCount == count)
2039: return;
2040:
2041: int oldValue = toggleClickCount;
2042: toggleClickCount = count;
2043: firePropertyChange(TOGGLE_CLICK_COUNT_PROPERTY, oldValue, count);
2044: }
2045:
2046: public void scrollPathToVisible(TreePath path)
2047: {
2048: if (path == null)
2049: return;
2050:
2051: Object[] oPath = path.getPath();
2052: TreePath temp = new TreePath(oPath[0]);
2053: boolean stop = false;
2054: int i = 1;
2055: while (!stop)
2056: {
2057: while (isVisible(temp))
2058: if (i < oPath.length)
2059: temp = temp.pathByAddingChild(oPath[i++]);
2060: else
2061: {
2062: stop = true;
2063: break;
2064: }
2065: makeVisible(temp);
2066: }
2067: Rectangle rect = getPathBounds(path);
2068: scrollRectToVisible(rect);
2069: revalidate();
2070: repaint();
2071: }
2072:
2073: public void scrollRowToVisible(int row)
2074: {
2075: scrollPathToVisible(getPathForRow(row));
2076: }
2077:
2078: public boolean getScrollsOnExpand()
2079: {
2080: return scrollsOnExpand;
2081: }
2082:
2083: public void setScrollsOnExpand(boolean scroll)
2084: {
2085: if (scrollsOnExpand == scroll)
2086: return;
2087:
2088: boolean oldValue = scrollsOnExpand;
2089: scrollsOnExpand = scroll;
2090: firePropertyChange(SCROLLS_ON_EXPAND_PROPERTY, oldValue, scroll);
2091: }
2092:
2093: public void setSelectionPath(TreePath path)
2094: {
2095: selectionModel.setSelectionPath(path);
2096: }
2097:
2098: public void setSelectionPaths(TreePath[] paths)
2099: {
2100: selectionModel.setSelectionPaths(paths);
2101: }
2102:
2103: public void setSelectionRow(int row)
2104: {
2105: TreePath path = getPathForRow(row);
2106:
2107: if (path != null)
2108: selectionModel.setSelectionPath(path);
2109: }
2110:
2111: public void setSelectionRows(int[] rows)
2112: {
2113:
2114: if (rows == null || getUI() == null)
2115: return;
2116:
2117: TreePath[] paths = new TreePath[rows.length];
2118:
2119: for (int i = rows.length - 1; i >= 0; --i)
2120: paths[i] = getPathForRow(rows[i]);
2121:
2122: setSelectionPaths(paths);
2123: }
2124:
2125: public void setSelectionInterval(int index0, int index1)
2126: {
2127: TreePath[] paths = getPathBetweenRows(index0, index1);
2128:
2129: if (paths != null)
2130: setSelectionPaths(paths);
2131: }
2132:
2133: public void addSelectionPath(TreePath path)
2134: {
2135: selectionModel.addSelectionPath(path);
2136: }
2137:
2138: public void addSelectionPaths(TreePath[] paths)
2139: {
2140: selectionModel.addSelectionPaths(paths);
2141: }
2142:
2143: public void addSelectionRow(int row)
2144: {
2145: TreePath path = getPathForRow(row);
2146:
2147: if (path != null)
2148: selectionModel.addSelectionPath(path);
2149: }
2150:
2151: public void addSelectionRows(int[] rows)
2152: {
2153:
2154: if (rows == null || getUI() == null)
2155: return;
2156:
2157: TreePath[] paths = new TreePath[rows.length];
2158:
2159: for (int i = rows.length - 1; i >= 0; --i)
2160: paths[i] = getPathForRow(rows[i]);
2161:
2162: addSelectionPaths(paths);
2163: }
2164:
2165: public void addSelectionInterval(int index0, int index1)
2166: {
2167: TreePath[] paths = getPathBetweenRows(index0, index1);
2168:
2169: if (paths != null)
2170: addSelectionPaths(paths);
2171: }
2172:
2173: public void removeSelectionPath(TreePath path)
2174: {
2175: selectionModel.removeSelectionPath(path);
2176: }
2177:
2178: public void removeSelectionPaths(TreePath[] paths)
2179: {
2180: selectionModel.removeSelectionPaths(paths);
2181: }
2182:
2183: public void removeSelectionRow(int row)
2184: {
2185: TreePath path = getPathForRow(row);
2186:
2187: if (path != null)
2188: selectionModel.removeSelectionPath(path);
2189: }
2190:
2191: public void removeSelectionRows(int[] rows)
2192: {
2193: if (rows == null || getUI() == null)
2194: return;
2195:
2196: TreePath[] paths = new TreePath[rows.length];
2197:
2198: for (int i = rows.length - 1; i >= 0; --i)
2199: paths[i] = getPathForRow(rows[i]);
2200:
2201: removeSelectionPaths(paths);
2202: }
2203:
2204: public void removeSelectionInterval(int index0, int index1)
2205: {
2206: TreePath[] paths = getPathBetweenRows(index0, index1);
2207:
2208: if (paths != null)
2209: removeSelectionPaths(paths);
2210: }
2211:
2212: public void clearSelection()
2213: {
2214: selectionModel.clearSelection();
2215: setLeadSelectionPath(null);
2216: }
2217:
2218: public TreePath getLeadSelectionPath()
2219: {
2220: return leadSelectionPath;
2221: }
2222:
2223:
2226: public void setLeadSelectionPath(TreePath path)
2227: {
2228: if (leadSelectionPath == path)
2229: return;
2230:
2231: TreePath oldValue = leadSelectionPath;
2232: leadSelectionPath = path;
2233: firePropertyChange(LEAD_SELECTION_PATH_PROPERTY, oldValue, path);
2234: }
2235:
2236:
2239: public TreePath getAnchorSelectionPath()
2240: {
2241: return anchorSelectionPath;
2242: }
2243:
2244:
2247: public void setAnchorSelectionPath(TreePath path)
2248: {
2249: if (anchorSelectionPath == path)
2250: return;
2251:
2252: TreePath oldValue = anchorSelectionPath;
2253: anchorSelectionPath = path;
2254: firePropertyChange(ANCHOR_SELECTION_PATH_PROPERTY, oldValue, path);
2255: }
2256:
2257: public int getLeadSelectionRow()
2258: {
2259: return selectionModel.getLeadSelectionRow();
2260: }
2261:
2262: public int getMaxSelectionRow()
2263: {
2264: return selectionModel.getMaxSelectionRow();
2265: }
2266:
2267: public int getMinSelectionRow()
2268: {
2269: return selectionModel.getMinSelectionRow();
2270: }
2271:
2272: public int getSelectionCount()
2273: {
2274: return selectionModel.getSelectionCount();
2275: }
2276:
2277: public TreePath getSelectionPath()
2278: {
2279: return selectionModel.getSelectionPath();
2280: }
2281:
2282: public TreePath[] getSelectionPaths()
2283: {
2284: return selectionModel.getSelectionPaths();
2285: }
2286:
2287: public int[] getSelectionRows()
2288: {
2289: return selectionModel.getSelectionRows();
2290: }
2291:
2292: public boolean isPathSelected(TreePath path)
2293: {
2294: return selectionModel.isPathSelected(path);
2295: }
2296:
2297: public boolean isRowSelected(int row)
2298: {
2299: return selectionModel.isPathSelected(getPathForRow(row));
2300: }
2301:
2302: public boolean isSelectionEmpty()
2303: {
2304: return selectionModel.isSelectionEmpty();
2305: }
2306:
2307:
2314: public boolean getDragEnabled()
2315: {
2316: return dragEnabled;
2317: }
2318:
2319:
2326: public void setDragEnabled(boolean enabled)
2327: {
2328: dragEnabled = enabled;
2329: }
2330:
2331: public int getRowCount()
2332: {
2333: TreeUI ui = getUI();
2334:
2335: if (ui != null)
2336: return ui.getRowCount(this);
2337:
2338: return 0;
2339: }
2340:
2341: public void collapsePath(TreePath path)
2342: {
2343: try
2344: {
2345: fireTreeWillCollapse(path);
2346: }
2347: catch (ExpandVetoException ev)
2348: {
2349:
2350: }
2351: setExpandedState(path, false);
2352: fireTreeCollapsed(path);
2353: }
2354:
2355: public void collapseRow(int row)
2356: {
2357: if (row < 0 || row >= getRowCount())
2358: return;
2359:
2360: TreePath path = getPathForRow(row);
2361:
2362: if (path != null)
2363: collapsePath(path);
2364: }
2365:
2366: public void expandPath(TreePath path)
2367: {
2368:
2369: if (path == null)
2370: return;
2371:
2372: try
2373: {
2374: fireTreeWillExpand(path);
2375: }
2376: catch (ExpandVetoException ev)
2377: {
2378:
2379: }
2380:
2381: setExpandedState(path, true);
2382: fireTreeExpanded(path);
2383: }
2384:
2385: public void expandRow(int row)
2386: {
2387: if (row < 0 || row >= getRowCount())
2388: return;
2389:
2390: TreePath path = getPathForRow(row);
2391:
2392: if (path != null)
2393: expandPath(path);
2394: }
2395:
2396: public boolean isCollapsed(TreePath path)
2397: {
2398: return !isExpanded(path);
2399: }
2400:
2401: public boolean isCollapsed(int row)
2402: {
2403: if (row < 0 || row >= getRowCount())
2404: return false;
2405:
2406: TreePath path = getPathForRow(row);
2407:
2408: if (path != null)
2409: return isCollapsed(path);
2410:
2411: return false;
2412: }
2413:
2414: public boolean isExpanded(TreePath path)
2415: {
2416: if (path == null)
2417: return false;
2418:
2419: Object state = nodeStates.get(path);
2420:
2421: if ((state == null) || (state != EXPANDED))
2422: return false;
2423:
2424: TreePath parent = path.getParentPath();
2425:
2426: if (parent != null)
2427: return isExpanded(parent);
2428:
2429: return true;
2430: }
2431:
2432: public boolean isExpanded(int row)
2433: {
2434: if (row < 0 || row >= getRowCount())
2435: return false;
2436:
2437: TreePath path = getPathForRow(row);
2438:
2439: if (path != null)
2440: return isExpanded(path);
2441:
2442: return false;
2443: }
2444:
2445:
2448: public boolean getExpandsSelectedPaths()
2449: {
2450: return expandsSelectedPaths;
2451: }
2452:
2453:
2456: public void setExpandsSelectedPaths(boolean flag)
2457: {
2458: if (expandsSelectedPaths == flag)
2459: return;
2460:
2461: boolean oldValue = expandsSelectedPaths;
2462: expandsSelectedPaths = flag;
2463: firePropertyChange(EXPANDS_SELECTED_PATHS_PROPERTY, oldValue, flag);
2464: }
2465:
2466: public Rectangle getPathBounds(TreePath path)
2467: {
2468: TreeUI ui = getUI();
2469:
2470: if (ui == null)
2471: return null;
2472:
2473: return ui.getPathBounds(this, path);
2474: }
2475:
2476: public Rectangle getRowBounds(int row)
2477: {
2478: TreePath path = getPathForRow(row);
2479:
2480: if (path != null)
2481: return getPathBounds(path);
2482:
2483: return null;
2484: }
2485:
2486: public boolean isEditing()
2487: {
2488: TreeUI ui = getUI();
2489:
2490: if (ui != null)
2491: return ui.isEditing(this);
2492:
2493: return false;
2494: }
2495:
2496: public boolean stopEditing()
2497: {
2498: TreeUI ui = getUI();
2499:
2500: if (ui != null)
2501: return ui.stopEditing(this);
2502:
2503: return false;
2504: }
2505:
2506: public void cancelEditing()
2507: {
2508: TreeUI ui = getUI();
2509:
2510: if (ui != null)
2511: ui.cancelEditing(this);
2512: }
2513:
2514: public void startEditingAtPath(TreePath path)
2515: {
2516: TreeUI ui = getUI();
2517:
2518: if (ui != null)
2519: ui.startEditingAtPath(this, path);
2520: }
2521:
2522: public TreePath getEditingPath()
2523: {
2524: TreeUI ui = getUI();
2525:
2526: if (ui != null)
2527: return ui.getEditingPath(this);
2528:
2529: return null;
2530: }
2531:
2532: public TreePath getPathForLocation(int x, int y)
2533: {
2534: TreePath path = getClosestPathForLocation(x, y);
2535:
2536: if (path != null)
2537: {
2538: Rectangle rect = getPathBounds(path);
2539:
2540: if ((rect != null) && rect.contains(x, y))
2541: return path;
2542: }
2543:
2544: return null;
2545: }
2546:
2547: public int getRowForLocation(int x, int y)
2548: {
2549: TreePath path = getPathForLocation(x, y);
2550:
2551: if (path != null)
2552: return getRowForPath(path);
2553:
2554: return -1;
2555: }
2556:
2557: public TreePath getClosestPathForLocation(int x, int y)
2558: {
2559: TreeUI ui = getUI();
2560:
2561: if (ui != null)
2562: return ui.getClosestPathForLocation(this, x, y);
2563:
2564: return null;
2565: }
2566:
2567: public int getClosestRowForLocation(int x, int y)
2568: {
2569: TreePath path = getClosestPathForLocation(x, y);
2570:
2571: if (path != null)
2572: return getRowForPath(path);
2573:
2574: return -1;
2575: }
2576:
2577: public Object getLastSelectedPathComponent()
2578: {
2579: TreePath path = getSelectionPath();
2580:
2581: if (path != null)
2582: return path.getLastPathComponent();
2583:
2584: return null;
2585: }
2586:
2587: private void doExpandParents(TreePath path, boolean state)
2588: {
2589: TreePath parent = path.getParentPath();
2590:
2591: if (!isExpanded(parent) && parent != null)
2592: doExpandParents(parent, false);
2593:
2594: nodeStates.put(path, state ? EXPANDED : COLLAPSED);
2595: }
2596:
2597: protected void setExpandedState(TreePath path, boolean state)
2598: {
2599: if (path == null)
2600: return;
2601:
2602: doExpandParents(path, state);
2603: }
2604:
2605: protected void clearToggledPaths()
2606: {
2607: nodeStates.clear();
2608: }
2609:
2610: protected Enumeration getDescendantToggledPaths(TreePath parent)
2611: {
2612: if (parent == null)
2613: return null;
2614:
2615: Enumeration nodes = nodeStates.keys();
2616: Vector result = new Vector();
2617:
2618: while (nodes.hasMoreElements())
2619: {
2620: TreePath path = (TreePath) nodes.nextElement();
2621:
2622: if (path.isDescendant(parent))
2623: result.addElement(path);
2624: }
2625:
2626: return result.elements();
2627: }
2628:
2629: public boolean hasBeenExpanded(TreePath path)
2630: {
2631: if (path == null)
2632: return false;
2633:
2634: return nodeStates.get(path) != null;
2635: }
2636:
2637: public boolean isVisible(TreePath path)
2638: {
2639: if (path == null)
2640: return false;
2641:
2642: TreePath parent = path.getParentPath();
2643:
2644: if (parent == null)
2645: return true;
2646:
2647: return isExpanded(parent);
2648: }
2649:
2650: public void makeVisible(TreePath path)
2651: {
2652: if (path == null)
2653: return;
2654:
2655: expandPath(path.getParentPath());
2656: }
2657:
2658: public boolean isPathEditable(TreePath path)
2659: {
2660: return isEditable();
2661: }
2662:
2663:
2668: protected TreeModelListener createTreeModelListener()
2669: {
2670: return new TreeModelHandler();
2671: }
2672:
2673:
2679: protected static TreeModel getDefaultTreeModel()
2680: {
2681: DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root node");
2682: DefaultMutableTreeNode child1 = new DefaultMutableTreeNode("Child node 1");
2683: DefaultMutableTreeNode child11 =
2684: new DefaultMutableTreeNode("Child node 1.1");
2685: DefaultMutableTreeNode child12 =
2686: new DefaultMutableTreeNode("Child node 1.2");
2687: DefaultMutableTreeNode child13 =
2688: new DefaultMutableTreeNode("Child node 1.3");
2689: DefaultMutableTreeNode child2 = new DefaultMutableTreeNode("Child node 2");
2690: DefaultMutableTreeNode child21 =
2691: new DefaultMutableTreeNode("Child node 2.1");
2692: DefaultMutableTreeNode child22 =
2693: new DefaultMutableTreeNode("Child node 2.2");
2694: DefaultMutableTreeNode child23 =
2695: new DefaultMutableTreeNode("Child node 2.3");
2696: DefaultMutableTreeNode child24 =
2697: new DefaultMutableTreeNode("Child node 2.4");
2698:
2699: DefaultMutableTreeNode child3 = new DefaultMutableTreeNode("Child node 3");
2700: root.add(child1);
2701: root.add(child2);
2702: root.add(child3);
2703: child1.add(child11);
2704: child1.add(child12);
2705: child1.add(child13);
2706: child2.add(child21);
2707: child2.add(child22);
2708: child2.add(child23);
2709: child2.add(child24);
2710: return new DefaultTreeModel(root);
2711: }
2712:
2713:
2728: public String convertValueToText(Object value, boolean selected,
2729: boolean expanded, boolean leaf, int row, boolean hasFocus)
2730: {
2731: return value.toString();
2732: }
2733:
2734:
2741: public String paramString()
2742: {
2743:
2744:
2745:
2746: return "";
2747: }
2748:
2749:
2759: public Enumeration getExpandedDescendants(TreePath path)
2760: {
2761: Enumeration paths = nodeStates.keys();
2762: Vector relevantPaths = new Vector();
2763: while (paths.hasMoreElements())
2764: {
2765: TreePath nextPath = (TreePath) paths.nextElement();
2766: if (nodeStates.get(nextPath) == EXPANDED
2767: && path.isDescendant(nextPath))
2768: {
2769: relevantPaths.add(nextPath);
2770: }
2771: }
2772: return relevantPaths.elements();
2773: }
2774:
2775:
2793: public TreePath getNextMatch(String prefix, int startingRow,
2794: Position.Bias bias)
2795: {
2796: if (prefix == null)
2797: throw new IllegalArgumentException("The argument 'prefix' must not be"
2798: + " null.");
2799: if (startingRow < 0)
2800: throw new IllegalArgumentException("The argument 'startingRow' must not"
2801: + " be less than zero.");
2802:
2803: int size = getRowCount();
2804: if (startingRow > size)
2805: throw new IllegalArgumentException("The argument 'startingRow' must not"
2806: + " be greater than the number of"
2807: + " elements in the TreeModel.");
2808:
2809: TreePath foundPath = null;
2810: if (bias == Position.Bias.Forward)
2811: {
2812: for (int i = startingRow; i < size; i++)
2813: {
2814: TreePath path = getPathForRow(i);
2815: Object o = path.getLastPathComponent();
2816:
2817:
2818: String item = convertValueToText(o, isRowSelected(i),
2819: isExpanded(i), treeModel.isLeaf(o),
2820: i, false);
2821: if (item.startsWith(prefix))
2822: {
2823: foundPath = path;
2824: break;
2825: }
2826: }
2827: }
2828: else
2829: {
2830: for (int i = startingRow; i >= 0; i--)
2831: {
2832: TreePath path = getPathForRow(i);
2833: Object o = path.getLastPathComponent();
2834:
2835:
2836: String item = convertValueToText(o, isRowSelected(i),
2837: isExpanded(i), treeModel.isLeaf(o), i, false);
2838: if (item.startsWith(prefix))
2839: {
2840: foundPath = path;
2841: break;
2842: }
2843: }
2844: }
2845: return foundPath;
2846: }
2847:
2848:
2863: protected boolean removeDescendantSelectedPaths(TreePath path,
2864: boolean includeSelected)
2865: {
2866: boolean removedSomething = false;
2867: TreePath[] selected = getSelectionPaths();
2868: for (int index = 0; index < selected.length; index++)
2869: {
2870: if ((selected[index] == path && includeSelected)
2871: || (selected[index].isDescendant(path)))
2872: {
2873: removeSelectionPath(selected[index]);
2874: removedSomething = true;
2875: }
2876: }
2877: return removedSomething;
2878: }
2879:
2880:
2887: protected void removeDescendantToggledPaths(Enumeration toRemove)
2888: {
2889: while (toRemove.hasMoreElements())
2890: {
2891: TreePath current = (TreePath) toRemove.nextElement();
2892: Enumeration descendants = getDescendantToggledPaths(current);
2893:
2894: while (descendants.hasMoreElements())
2895: {
2896: TreePath currentDes = (TreePath) descendants.nextElement();
2897: if (isExpanded(currentDes))
2898: nodeStates.remove(currentDes);
2899: }
2900: }
2901: }
2902:
2903:
2909: public void treeDidChange()
2910: {
2911: repaint();
2912: }
2913: }