| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* JTree.java 2: Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: package javax.swing; 39: 40: import java.awt.Color; 41: import java.awt.Cursor; 42: import java.awt.Dimension; 43: import java.awt.Font; 44: import java.awt.FontMetrics; 45: import java.awt.Point; 46: import java.awt.Rectangle; 47: import java.awt.event.FocusListener; 48: import java.beans.PropertyChangeListener; 49: import java.io.Serializable; 50: import java.util.Enumeration; 51: import java.util.Hashtable; 52: import java.util.Iterator; 53: import java.util.Locale; 54: import java.util.Vector; 55: 56: import javax.accessibility.Accessible; 57: import javax.accessibility.AccessibleAction; 58: import javax.accessibility.AccessibleComponent; 59: import javax.accessibility.AccessibleContext; 60: import javax.accessibility.AccessibleRole; 61: import javax.accessibility.AccessibleSelection; 62: import javax.accessibility.AccessibleState; 63: import javax.accessibility.AccessibleStateSet; 64: import javax.accessibility.AccessibleText; 65: import javax.accessibility.AccessibleValue; 66: import javax.swing.event.TreeExpansionEvent; 67: import javax.swing.event.TreeExpansionListener; 68: import javax.swing.event.TreeModelEvent; 69: import javax.swing.event.TreeModelListener; 70: import javax.swing.event.TreeSelectionEvent; 71: import javax.swing.event.TreeSelectionListener; 72: import javax.swing.event.TreeWillExpandListener; 73: import javax.swing.plaf.TreeUI; 74: import javax.swing.text.Position; 75: import javax.swing.tree.DefaultMutableTreeNode; 76: import javax.swing.tree.DefaultTreeModel; 77: import javax.swing.tree.DefaultTreeSelectionModel; 78: import javax.swing.tree.ExpandVetoException; 79: import javax.swing.tree.TreeCellEditor; 80: import javax.swing.tree.TreeCellRenderer; 81: import javax.swing.tree.TreeModel; 82: import javax.swing.tree.TreeNode; 83: import javax.swing.tree.TreePath; 84: import javax.swing.tree.TreeSelectionModel; 85: 86: public class JTree extends JComponent implements Scrollable, Accessible 87: { 88: 89: /** 90: * This class implements accessibility support for the JTree class. It 91: * provides an implementation of the Java Accessibility API appropriate 92: * to tree user-interface elements. 93: */ 94: protected class AccessibleJTree extends JComponent.AccessibleJComponent 95: implements AccessibleSelection, TreeSelectionListener, TreeModelListener, 96: TreeExpansionListener 97: { 98: 99: /** 100: * This class implements accessibility support for the JTree child. It provides 101: * an implementation of the Java Accessibility API appropriate to tree nodes. 102: */ 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: /** 118: * Constructs an AccessibleJTreeNode 119: * 120: * @param t - the current tree 121: * @param p - the current path to be dealt with 122: * @param ap - the accessible object to use 123: */ 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: // Add all the children of this path that may already be 137: // selected to the selection list. 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: // Add all the actions available for a node to 147: // the action list. 148: actionList.add("EXPAND"); 149: actionList.add("COLLAPSE"); 150: actionList.add("EDIT"); 151: actionList.add("SELECT"); 152: actionList.add("DESELECT"); 153: } 154: 155: /** 156: * Adds the specified selected item in the object to the object's 157: * selection. 158: * 159: * @param i - the i-th child of this node. 160: */ 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: /** 177: * Adds the specified focus listener to receive focus events 178: * from this component. 179: * 180: * @param l - the new focus listener 181: */ 182: public void addFocusListener(FocusListener l) 183: { 184: tree.addFocusListener(l); 185: } 186: 187: /** 188: * Add a PropertyChangeListener to the listener list. 189: * 190: * @param l - the new property change listener 191: */ 192: public void addPropertyChangeListener(PropertyChangeListener l) 193: { 194: // Nothing to do here. 195: } 196: 197: /** 198: * Clears the selection in the object, so that nothing in the 199: * object is selected. 200: */ 201: public void clearAccessibleSelection() 202: { 203: selectionList.clear(); 204: } 205: 206: /** 207: * Checks whether the specified point is within this object's 208: * bounds, where the point's x and y coordinates are defined to be 209: * relative to the coordinate system of the object. 210: * 211: * @param p - the point to check 212: * @return true if p is in the bounds 213: */ 214: public boolean contains(Point p) 215: { 216: return getBounds().contains(p); 217: } 218: 219: /** 220: * Perform the specified Action on the tree node. 221: * 222: * @param i - the i-th action to perform 223: * @return true if the the action was performed; else false. 224: */ 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: /** 246: * Get the AccessibleAction associated with this object. 247: * 248: * @return the action 249: */ 250: public AccessibleAction getAccessibleAction() 251: { 252: return this; 253: } 254: 255: /** 256: * Returns the number of accessible actions available in this tree node. 257: * 258: * @return the number of actions 259: */ 260: public int getAccessibleActionCount() 261: { 262: return actionList.size(); 263: } 264: 265: /** 266: * Return a description of the specified action of the tree node. 267: * 268: * @param i - the i-th action's description 269: * @return a description of the action 270: */ 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: /** 279: * Returns the Accessible child, if one exists, contained at the 280: * local coordinate Point. 281: * 282: * @param p - the point of the accessible 283: * @return the accessible at point p if it exists 284: */ 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: /** 294: * Return the specified Accessible child of the object. 295: * 296: * @param i - the i-th child of the current path 297: * @return the child if it exists 298: */ 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: /** 312: * Returns the number of accessible children in the object. 313: * 314: * @return the number of children the current node has 315: */ 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: /** 325: * Get the AccessibleComponent associated with this object. 326: * 327: * @return the accessible component if it is supported. 328: */ 329: public AccessibleComponent getAccessibleComponent() 330: { 331: return this; 332: } 333: 334: /** 335: * Get the AccessibleContext associated with this tree node. 336: * 337: * @return an instance of this class 338: */ 339: public AccessibleContext getAccessibleContext() 340: { 341: return this; 342: } 343: 344: /** 345: * Get the accessible description of this object. 346: * 347: * @return the accessible description 348: */ 349: public String getAccessibleDescription() 350: { 351: return super.getAccessibleDescription(); 352: } 353: 354: /** 355: * Get the index of this object in its accessible parent. 356: * 357: * @return the index of this in the parent. 358: */ 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: /** 372: * Get the accessible name of this object. 373: * 374: * @return the accessible name 375: */ 376: public String getAccessibleName() 377: { 378: return super.getAccessibleName(); 379: } 380: 381: /** 382: * Get the Accessible parent of this object. 383: * 384: * @return the accessible parent if it exists. 385: */ 386: public Accessible getAccessibleParent() 387: { 388: return super.getAccessibleParent(); 389: } 390: 391: /** 392: * Get the role of this object. 393: * 394: * @return the accessible role 395: */ 396: public AccessibleRole getAccessibleRole() 397: { 398: return AccessibleJTree.this.getAccessibleRole(); 399: } 400: 401: /** 402: * Get the AccessibleSelection associated with this object if one exists. 403: * 404: * @return the accessible selection for this. 405: */ 406: public AccessibleSelection getAccessibleSelection() 407: { 408: return this; 409: } 410: 411: /** 412: * Returns an Accessible representing the specified selected item 413: * in the object. 414: * 415: * @return the accessible representing a certain selected item. 416: */ 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: /** 426: * Returns the number of items currently selected. 427: * 428: * @return the number of items selected. 429: */ 430: public int getAccessibleSelectionCount() 431: { 432: return selectionList.size(); 433: } 434: 435: /** 436: * Get the state set of this object. 437: * 438: * @return the state set for this object 439: */ 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: /** 472: * Get the AccessibleText associated with this object if one exists. 473: * 474: * @return the accessible text 475: */ 476: public AccessibleText getAccessibleText() 477: { 478: return super.getAccessibleText(); 479: } 480: 481: /** 482: * Get the AccessibleValue associated with this object if one exists. 483: * 484: * @return the accessible value if it exists 485: */ 486: public AccessibleValue getAccessibleValue() 487: { 488: return super.getAccessibleValue(); 489: } 490: 491: /** 492: * Get the background color of this object. 493: * 494: * @return the color of the background. 495: */ 496: public Color getBackground() 497: { 498: return tree.getBackground(); 499: } 500: 501: /** 502: * Gets the bounds of this object in the form of a Rectangle object. 503: * 504: * @return the bounds of the current node. 505: */ 506: public Rectangle getBounds() 507: { 508: return tree.getPathBounds(tp); 509: } 510: 511: /** 512: * Gets the Cursor of this object. 513: * 514: * @return the cursor for the current node 515: */ 516: public Cursor getCursor() 517: { 518: return cursor; 519: } 520: 521: /** 522: * Gets the Font of this object. 523: * 524: * @return the font for the current node 525: */ 526: public Font getFont() 527: { 528: return tree.getFont(); 529: } 530: 531: /** 532: * Gets the FontMetrics of this object. 533: * 534: * @param f - the current font. 535: * @return the font metrics for the given font. 536: */ 537: public FontMetrics getFontMetrics(Font f) 538: { 539: return tree.getFontMetrics(f); 540: } 541: 542: /** 543: * Get the foreground color of this object. 544: * 545: * @return the foreground for this object. 546: */ 547: public Color getForeground() 548: { 549: return tree.getForeground(); 550: } 551: 552: /** 553: * Gets the locale of the component. 554: * 555: * @return the locale of the component. 556: */ 557: public Locale getLocale() 558: { 559: return tree.getLocale(); 560: } 561: 562: /** 563: * Gets the location of the object relative to the 564: * parent in the form of a point specifying the object's 565: * top-left corner in the screen's coordinate space. 566: * 567: * @return the location of the current node. 568: */ 569: public Point getLocation() 570: { 571: return getLocationInJTree(); 572: } 573: 574: /** 575: * Returns the location in the tree. 576: * 577: * @return the location in the JTree. 578: */ 579: protected Point getLocationInJTree() 580: { 581: Rectangle bounds = tree.getPathBounds(tp); 582: return new Point(bounds.x, bounds.y); 583: } 584: 585: /** 586: * Returns the location of the object on the screen. 587: * 588: * @return the location of the object on the screen. 589: */ 590: public Point getLocationOnScreen() 591: { 592: Point loc = getLocation(); 593: SwingUtilities.convertPointToScreen(loc, tree); 594: return loc; 595: } 596: 597: /** 598: * Returns the size of this object in the form of a Dimension object. 599: * 600: * @return the size of the object 601: */ 602: public Dimension getSize() 603: { 604: Rectangle b = getBounds(); 605: return b.getSize(); 606: } 607: 608: /** 609: * Returns true if the current child of this object is selected. 610: * 611: * @param i - the child of the current node 612: * @return true if the child is selected. 613: */ 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: /** 623: * Determines if the object is enabled. 624: * 625: * @return true if the tree is enabled 626: */ 627: public boolean isEnabled() 628: { 629: return tree.isEnabled(); 630: } 631: 632: /** 633: * Returns whether this object can accept focus or not. 634: * 635: * @return true, it is always focus traversable 636: */ 637: public boolean isFocusTraversable() 638: { 639: return true; 640: } 641: 642: /** 643: * Determines if the object is showing. 644: * 645: * @return true if the object is visible and the 646: * parent is visible. 647: */ 648: public boolean isShowing() 649: { 650: return isVisible() && tree.isShowing(); 651: } 652: 653: /** 654: * Determines if the object is visible. 655: * 656: * @return true if the object is visible. 657: */ 658: public boolean isVisible() 659: { 660: return tree.isVisible(tp); 661: } 662: 663: /** 664: * Removes the specified selected item in the object from the 665: * object's selection. 666: * 667: * @param i - the specified item to remove 668: */ 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: /** 688: * Removes the specified focus listener so it no longer receives focus 689: * events from this component. 690: * 691: * @param l - the focus listener to remove 692: */ 693: public void removeFocusListener(FocusListener l) 694: { 695: tree.removeFocusListener(l); 696: } 697: 698: /** 699: * Remove a PropertyChangeListener from the listener list. 700: * 701: * @param l - the property change listener to remove. 702: */ 703: public void removePropertyChangeListener(PropertyChangeListener l) 704: { 705: // Nothing to do here. 706: } 707: 708: /** 709: * Requests focus for this object. 710: */ 711: public void requestFocus() 712: { 713: tree.requestFocus(); 714: } 715: 716: /** 717: * Causes every selected item in the object to be selected if the object 718: * supports multiple selections. 719: */ 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: /** 743: * Set the accessible description of this object. 744: * 745: * @param s - the string to set the accessible description to. 746: */ 747: public void setAccessibleDescription(String s) 748: { 749: super.setAccessibleDescription(s); 750: } 751: 752: /** 753: * Set the localized accessible name of this object. 754: * 755: * @param s - the string to set the accessible name to. 756: */ 757: public void setAccessibleName(String s) 758: { 759: super.setAccessibleName(s); 760: } 761: 762: /** 763: * Set the background color of this object. 764: * 765: * @param c - the color to set the background to. 766: */ 767: public void setBackground(Color c) 768: { 769: // Nothing to do here. 770: } 771: 772: /** 773: * Sets the bounds of this object in the form of a Rectangle object. 774: * 775: * @param r - the bounds to set the object o 776: */ 777: public void setBounds(Rectangle r) 778: { 779: // Nothing to do here. 780: } 781: 782: /** 783: * Sets the Cursor of this object. 784: * 785: * @param c - the new cursor 786: */ 787: public void setCursor(Cursor c) 788: { 789: cursor = c; 790: } 791: 792: /** 793: * Sets the enabled state of the object. 794: * 795: * @param b - boolean to enable or disable object 796: */ 797: public void setEnabled(boolean b) 798: { 799: // Nothing to do here. 800: } 801: 802: /** 803: * Sets the Font of this object. 804: * 805: * @param f - the new font. 806: */ 807: public void setFont(Font f) 808: { 809: // Nothing to do here. 810: } 811: 812: /** 813: * Sets the foreground color of this object. 814: * 815: * @param c - the new foreground color. 816: */ 817: public void setForeground(Color c) 818: { 819: // Nothing to do here. 820: } 821: 822: /** 823: * Sets the location of the object relative to the parent. 824: * 825: * @param p - the new location for the object. 826: */ 827: public void setLocation(Point p) 828: { 829: // Nothing to do here. 830: } 831: 832: /** 833: * Resizes this object so that it has width and height. 834: * 835: * @param d - the new size for the object. 836: */ 837: public void setSize(Dimension d) 838: { 839: // Nothing to do here. 840: } 841: 842: /** 843: * Sets the visible state of the object. 844: * 845: * @param b - sets the objects visibility. 846: */ 847: public void setVisible(boolean b) 848: { 849: // Nothing to do here. 850: } 851: } 852: 853: /** 854: * Constructor 855: */ 856: public AccessibleJTree() 857: { 858: // Nothing to do here. 859: } 860: 861: /** 862: * Adds the specified selected item in the object to the object's selection. 863: * 864: * @param i - the row to add to the tree's selection 865: */ 866: public void addAccessibleSelection(int i) 867: { 868: addSelectionInterval(i, i); 869: } 870: 871: /** 872: * Clears the selection in the object, so that nothing in the object is selected. 873: */ 874: public void clearAccessibleSelection() 875: { 876: clearSelection(); 877: } 878: 879: /** 880: * Fire a visible data property change notification. 881: */ 882: public void fireVisibleDataPropertyChange() 883: { 884: treeDidChange(); 885: } 886: 887: /** 888: * Returns the Accessible child, if one exists, contained at the local 889: * coordinate Point. 890: * 891: * @param p - the point of the accessible to get. 892: * @return the accessible at point p. 893: */ 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: /** 903: * Return the nth Accessible child of the object. 904: * 905: * @param i - the accessible child to get 906: * @return the i-th child 907: */ 908: public Accessible getAccessibleChild(int i) 909: { 910: return null; 911: } 912: 913: /** 914: * Returns the number of top-level children nodes of this JTree. 915: * 916: * @return the number of top-level children 917: */ 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: /** 927: * Get the index of this object in its accessible parent. 928: * 929: * @return the index of this object. 930: */ 931: public int getAccessibleIndexInParent() 932: { 933: return 0; 934: } 935: 936: /** 937: * Get the role of this object. 938: * 939: * @return the role of this object 940: */ 941: public AccessibleRole getAccessibleRole() 942: { 943: return AccessibleRole.TREE; 944: } 945: 946: /** 947: * Get the AccessibleSelection associated with this object. 948: * 949: * @return the accessible selection of the tree 950: */ 951: public AccessibleSelection getAccessibleSelection() 952: {