libjava/javax/swing/JTree.java

   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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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
  39 package javax.swing;
  40
  41 import java.awt.Dimension;
  42 import java.awt.Rectangle;
  43 import java.util.Enumeration;
  44 import java.util.Hashtable;
  45 import java.util.Iterator;
  46 import java.util.Vector;
  47
  48 import javax.accessibility.Accessible;
  49 import javax.accessibility.AccessibleContext;
  50 import javax.swing.event.TreeExpansionEvent;
  51 import javax.swing.event.TreeExpansionListener;
  52 import javax.swing.event.TreeSelectionEvent;
  53 import javax.swing.event.TreeSelectionListener;
  54 import javax.swing.event.TreeWillExpandListener;
  55 import javax.swing.plaf.TreeUI;
  56 import javax.swing.tree.DefaultMutableTreeNode;
  57 import javax.swing.tree.DefaultTreeCellRenderer;
  58 import javax.swing.tree.DefaultTreeModel;
  59 import javax.swing.tree.ExpandVetoException;
  60 import javax.swing.tree.TreeCellEditor;
  61 import javax.swing.tree.TreeCellRenderer;
  62 import javax.swing.tree.TreeModel;
  63 import javax.swing.tree.TreeNode;
  64 import javax.swing.tree.TreePath;
  65 import javax.swing.tree.TreeSelectionModel;
  66
  67
  68 public class JTree extends JComponent
  69   implements Scrollable, Accessible
  70 {
  71   private static final long serialVersionUID = 7559816092864483649L;
  72
  73   public static final String CELL_EDITOR_PROPERTY = "cellEditor";
  74   public static final String CELL_RENDERER_PROPERTY = "cellRenderer";
  75   public static final String EDITABLE_PROPERTY = "editable";
  76   public static final String INVOKES_STOP_CELL_EDITING_PROPERTY = "invokesStopCellEditing";
  77   public static final String LARGE_MODEL_PROPERTY = "largeModel";
  78   public static final String ROOT_VISIBLE_PROPERTY = "rootVisible";
  79   public static final String ROW_HEIGHT_PROPERTY = "rowHeight";
  80   public static final String SCROLLS_ON_EXPAND_PROPERTY = "scrollsOnExpand";
  81   public static final String SELECTION_MODEL_PROPERTY = "selectionModel";
  82   public static final String SHOWS_ROOT_HANDLES_PROPERTY = "showsRootHandles";
  83   public static final String TOGGLE_CLICK_COUNT_PROPERTY = "toggleClickCount";
  84   public static final String TREE_MODEL_PROPERTY = "model";
  85   public static final String VISIBLE_ROW_COUNT_PROPERTY = "visibleRowCount";
  86
  87   /** @since 1.3 */
  88   public static final String ANCHOR_SELECTION_PATH_PROPERTY = "anchorSelectionPath";
  89   /** @since 1.3 */
  90   public static final String LEAD_SELECTION_PATH_PROPERTY = "leadSelectionPath";
  91   /** @since 1.3 */
  92   public static final String EXPANDS_SELECTED_PATHS_PROPERTY = "expandsSelectedPaths";
  93
  94   private static final Object EXPANDED = new Object();
  95   private static final Object COLLAPSED = new Object();
  96
  97   private boolean dragEnabled;
  98   private boolean expandsSelectedPaths;
  99   private TreePath anchorSelectionPath;
 100   private TreePath leadSelectionPath;
 101
 102   /*
 103    * This contains the state of all nodes in the tree. Al/ entries map the
 104    * TreePath of a note to to its state. Valid states are EXPANDED and
 105    * COLLAPSED.  Nodes not in this Hashtable are assumed state COLLAPSED.
 106    */
 107   private Hashtable nodeStates;
 108
 109   protected transient TreeCellEditor cellEditor;
 110   protected transient TreeCellRenderer cellRenderer;
 111   protected boolean editable;
 112   protected boolean invokesStopCellEditing;
 113   protected boolean largeModel;
 114   protected boolean rootVisible;
 115   protected int rowHeight;
 116   protected boolean scrollsOnExpand;
 117   protected transient TreeSelectionModel selectionModel;
 118   protected boolean showsRootHandles;
 119   protected int toggleClickCount;
 120   protected transient TreeModel treeModel;
 121   protected int visibleRowCount;
 122
 123   /**
 124    * Creates a new <code>JTree</code> object.
 125    */
 126   public JTree()
 127   {
 128     this(createTreeModel(null));
 129   }
 130
 131   /**
 132    * Creates a new <code>JTree</code> object.
 133    *
 134    * @param value the initial nodes in the tree
 135    */
 136   public JTree(Hashtable value)
 137   {
 138     this(createTreeModel(value));
 139   }
 140
 141   /**
 142    * Creates a new <code>JTree</code> object.
 143    *
 144    * @param value the initial nodes in the tree
 145    */
 146   public JTree(Object[] value)
 147   {
 148     this(createTreeModel(value));
 149   }
 150
 151   /**
 152    * Creates a new <code>JTree</code> object.
 153    *
 154    * @param model the model to use
 155    */
 156   public JTree(TreeModel model)
 157   {
 158     treeModel = model;
 159     setCellRenderer(new DefaultTreeCellRenderer());
 160     updateUI();
 161   }
 162
 163   /**
 164    * Creates a new <code>JTree</code> object.
 165    *
 166    * @param root the root node
 167    */
 168   public JTree(TreeNode root)
 169   {
 170     this(root, false);
 171   }
 172
 173   /**
 174    * Creates a new <code>JTree</code> object.
 175    *
 176    * @param root the root node
 177    * @param asksAllowChildren if false, all nodes without children are leaf nodes.
 178    * If true, only nodes that do not allow children are leaf nodes.
 179    */
 180   public JTree(TreeNode root, boolean asksAllowChildren)
 181   {
 182     this(new DefaultTreeModel(root, asksAllowChildren));
 183   }
 184
 185   /**
 186    * Creates a new <code>JTree</code> object.
 187    *
 188    * @param value the initial nodes in the tree
 189    */
 190   public JTree(Vector value)
 191   {
 192     this(createTreeModel(value));
 193   }
 194
 195   public static class DynamicUtilTreeNode
 196     extends DefaultMutableTreeNode
 197   {
 198     protected Object childValue;
 199     protected boolean loadedChildren;
 200
 201     /**
 202      * Currently not set or used by this class.
 203      * It might be set and used in later versions of this class.
 204      */
 205     protected boolean hasChildren;
 206
 207     public DynamicUtilTreeNode(Object value,
 208                                Object children)
 209     {
 210       super(value);
 211       childValue = children;
 212       loadedChildren = false;
 213     }
 214
 215     public int getChildCount()
 216     {
 217       loadChildren();
 218       return super.getChildCount();
 219     }
 220
 221     protected void loadChildren()
 222     {
 223       if (!loadedChildren)
 224         {
 225           createChildren(this, childValue);
 226           loadedChildren = true;
 227         }
 228     }
 229
 230     public Enumeration children()
 231     {
 232       loadChildren();
 233       return super.children();
 234     }
 235
 236     public boolean isLeaf()
 237     {
 238       return (childValue == null ||
 239               !(childValue instanceof Hashtable
 240                || childValue instanceof Vector
 241                || childValue.getClass().isArray()));
 242     }
 243
 244     public static void createChildren(DefaultMutableTreeNode parent,
 245                                       Object children)
 246     {
 247       if (children instanceof Hashtable)
 248         {
 249           Hashtable tab = (Hashtable) children;
 250           Enumeration e = tab.keys();
 251           while (e.hasMoreElements())
 252             {
 253               Object key = e.nextElement();
 254               Object val = tab.get(key);
 255               parent.add(new DynamicUtilTreeNode(key, val));
 256             }
 257         }
 258       else if (children instanceof Vector)
 259         {
 260           Iterator i = ((Vector)children).iterator();
 261           while (i.hasNext())
 262             {
 263               Object n = i.next();
 264               parent.add(new DynamicUtilTreeNode(n,n));
 265             }
 266         }
 267       else if (children.getClass().isArray())
 268         {
 269           Object[] arr = (Object[]) children;
 270           for (int i = 0; i < arr.length; ++i)
 271             parent.add(new DynamicUtilTreeNode(arr[i], arr[i]));
 272       }
 273     }
 274   }
 275
 276   public int getRowForPath(TreePath path)
 277   {
 278     TreeUI ui = getUI();
 279
 280     if (ui != null)
 281       return ui.getRowForPath(this, path);
 282
 283     return -1;
 284   }
 285
 286   public TreePath getPathForRow(int row)
 287   {
 288     TreeUI ui = getUI();
 289     return ui != null ? ui.getPathForRow(this, row) : null;
 290   }
 291
 292   protected TreePath[] getPathBetweenRows(int index0, int index1)
 293   {
 294     TreeUI ui = getUI();
 295
 296     if (ui == null)
 297       return null;
 298
 299     int minIndex = Math.min(index0, index1);
 300     int maxIndex = Math.max(index0, index1);
 301     TreePath[] paths = new TreePath[maxIndex - minIndex + 1];
 302
 303     for (int i = minIndex; i <= maxIndex; ++i)
 304       paths[i - minIndex] = ui.getPathForRow(this, i);
 305
 306     return paths;
 307   }
 308
 309   /**
 310    * Creates a new <code>TreeModel</code> object.
 311    *
 312    * @param value the values stored in the model
 313    */
 314   protected static TreeModel createTreeModel(Object value)
 315   {
 316     return new DefaultTreeModel(new DynamicUtilTreeNode(value, value));
 317   }
 318
 319   /**
 320    * Return the UI associated with this <code>JTree</code> object.
 321    *
 322    * @return the associated <code>TreeUI</code> object
 323    */
 324   public TreeUI getUI()
 325   {
 326     return (TreeUI) ui;
 327   }
 328
 329   /**
 330    * Sets the UI associated with this <code>JTree</code> object.
 331    *
 332    * @param ui the <code>TreeUI</code> to associate
 333    */
 334   public void setUI(TreeUI ui)
 335   {
 336     super.setUI(ui);
 337   }
 338
 339   /**
 340    * This method resets the UI used to the Look and Feel defaults..
 341    */
 342   public void updateUI()
 343   {
 344     setUI((TreeUI) UIManager.getUI(this));
 345     revalidate();
 346     repaint();
 347   }
 348
 349   /**
 350    * This method returns the String ID of the UI class of  Separator.
 351    *
 352    * @return The UI class' String ID.
 353    */
 354   public String getUIClassID()
 355   {
 356     return "TreeUI";
 357   }
 358
 359   /**
 360    * Gets the AccessibleContext associated with this <code>JToggleButton</code>.
 361    *
 362    * @return the associated context
 363    */
 364   public AccessibleContext getAccessibleContext()
 365   {
 366     return null;
 367   }
 368
 369   /**
 370    * Returns the preferred viewport size..
 371    *
 372    * @return the preferred size
 373    */
 374   public Dimension getPreferredScrollableViewportSize()
 375   {
 376     return null;
 377   }
 378
 379   public int getScrollableUnitIncrement(Rectangle visibleRect,
 380                                         int orientation, int direction)
 381   {
 382     return 1;
 383   }
 384
 385   public int getScrollableBlockIncrement(Rectangle visibleRect,
 386                                          int orientation, int direction)
 387   {
 388     return 1;
 389   }
 390
 391   public boolean getScrollableTracksViewportWidth()
 392   {
 393     return false;
 394   }
 395
 396   public boolean getScrollableTracksViewportHeight()
 397   {
 398     return false;
 399   }
 400
 401   /**
 402    * Adds a <code>TreeExpansionListener</code> object to the tree.
 403    *
 404    * @param listener the listener to add
 405    */
 406   public void addTreeExpansionListener(TreeExpansionListener listener)
 407   {
 408     listenerList.add(TreeExpansionListener.class, listener);
 409   }
 410
 411   /**
 412    * Removes a <code>TreeExpansionListener</code> object from the tree.
 413    *
 414    * @param listener the listener to remove
 415    */
 416   public void removeTreeExpansionListener(TreeExpansionListener listener)
 417   {
 418     listenerList.remove(TreeExpansionListener.class, listener);
 419   }
 420
 421   /**
 422    * Returns all added <code>TreeExpansionListener</code> objects.
 423    *
 424    * @return an array of listeners
 425    */
 426   public TreeExpansionListener[] getTreeExpansionListeners()
 427   {
 428     return (TreeExpansionListener[]) getListeners(TreeExpansionListener.class);
 429   }
 430
 431   /**
 432    * Notifies all listeners that the tree was collapsed.
 433    *
 434    * @param path the path to the node that was collapsed
 435    */
 436   public void fireTreeCollapsed(TreePath path)
 437   {
 438     TreeExpansionEvent event = new TreeExpansionEvent(this, path);
 439     TreeExpansionListener[] listeners = getTreeExpansionListeners();
 440
 441     for (int index = 0; index < listeners.length; ++index)
 442       listeners[index].treeCollapsed(event);
 443   }
 444
 445   /**
 446    * Notifies all listeners that the tree was expanded.
 447    *
 448    * @param path the path to the node that was expanded
 449    */
 450   public void fireTreeExpanded(TreePath path)
 451   {
 452     TreeExpansionEvent event = new TreeExpansionEvent(this, path);
 453     TreeExpansionListener[] listeners = getTreeExpansionListeners();
 454
 455     for (int index = 0; index < listeners.length; ++index)
 456       listeners[index].treeExpanded(event);
 457   }
 458
 459   /**
 460    * Adds a <code>TreeSelctionListener</code> object to the tree.
 461    *
 462    * @param listener the listener to add
 463    */
 464   public void addTreeSelectionListener(TreeSelectionListener listener)
 465   {
 466     listenerList.add(TreeSelectionListener.class, listener);
 467   }
 468
 469   /**
 470    * Removes a <code>TreeSelectionListener</code> object from the tree.
 471    *
 472    * @param listener the listener to remove
 473    */
 474   public void removeTreeSelectionListener(TreeSelectionListener listener)
 475   {
 476     listenerList.remove(TreeSelectionListener.class, listener);
 477   }
 478
 479   /**
 480    * Returns all added <code>TreeSelectionListener</code> objects.
 481    *
 482    * @return an array of listeners
 483    */
 484   public TreeSelectionListener[] getTreeSelectionListeners()
 485   {
 486     return (TreeSelectionListener[]) getListeners(TreeSelectionListener.class);
 487   }
 488
 489   /**
 490    * Notifies all listeners when the selection of the tree changed.
 491    *
 492    * @param event the event to send
 493    */
 494   protected void fireValueChanged(TreeSelectionEvent event)
 495   {
 496     TreeSelectionListener[] listeners = getTreeSelectionListeners();
 497
 498     for (int index = 0; index < listeners.length; ++index)
 499       listeners[index].valueChanged(event);
 500   }
 501
 502   /**
 503    * Adds a <code>TreeWillExpandListener</code> object to the tree.
 504    *
 505    * @param listener the listener to add
 506    */
 507   public void addTreeWillExpandListener(TreeWillExpandListener listener)
 508   {
 509     listenerList.add(TreeWillExpandListener.class, listener);
 510   }
 511
 512   /**
 513    * Removes a <code>TreeWillExpandListener</code> object from the tree.
 514    *
 515    * @param listener the listener to remove
 516    */
 517   public void removeTreeWillExpandListener(TreeWillExpandListener listener)
 518   {
 519     listenerList.remove(TreeWillExpandListener.class, listener);
 520   }
 521
 522   /**
 523    * Returns all added <code>TreeWillExpandListener</code> objects.
 524    *
 525    * @return an array of listeners
 526    */
 527   public TreeWillExpandListener[] getTreeWillExpandListeners()
 528   {
 529     return (TreeWillExpandListener[]) getListeners(TreeWillExpandListener.class);
 530   }
 531
 532   /**
 533    * Notifies all listeners that the tree will collapse.
 534    *
 535    * @param path the path to the node that will collapse
 536    */
 537   public void fireTreeWillCollapse(TreePath path)
 538     throws ExpandVetoException
 539   {
 540     TreeExpansionEvent event = new TreeExpansionEvent(this, path);
 541     TreeWillExpandListener[] listeners = getTreeWillExpandListeners();
 542
 543     for (int index = 0; index < listeners.length; ++index)
 544       listeners[index].treeWillCollapse(event);
 545   }
 546
 547   /**
 548    * Notifies all listeners that the tree will expand.
 549    *
 550    * @param path the path to the node that will expand
 551    */
 552   public void fireTreeWillExpand(TreePath path)
 553     throws ExpandVetoException
 554   {
 555     TreeExpansionEvent event = new TreeExpansionEvent(this, path);
 556     TreeWillExpandListener[] listeners = getTreeWillExpandListeners();
 557
 558     for (int index = 0; index < listeners.length; ++index)
 559       listeners[index].treeWillExpand(event);
 560   }
 561
 562   /**
 563    * Returns the model of this <code>JTree</code> object.
 564    *
 565    * @return the associated <code>TreeModel</code>
 566    */
 567   public TreeModel getModel()
 568   {
 569     return treeModel;
 570   }
 571
 572   /**
 573    * Sets the model to use in <code>JTree</code>.
 574    *
 575    * @param model the <code>TreeModel</code> to use
 576    */
 577   public void setModel(TreeModel model)
 578   {
 579     if (treeModel == model)
 580       return;
 581
 582     TreeModel oldValue = treeModel;
 583     treeModel = model;
 584     firePropertyChange(TREE_MODEL_PROPERTY, oldValue, model);
 585   }
 586
 587   /**
 588    * Checks if this <code>JTree</code> object is editable.
 589    *
 590    * @return <code>true</code> if this tree object is editable,
 591    * <code>false</code> otherwise
 592    */
 593   public boolean isEditable()
 594   {
 595     return editable;
 596   }
 597
 598   /**
 599    * Sets the <code>editable</code> property.
 600    *
 601    * @param flag <code>true</code> to make this tree object editable,
 602    * <code>false</code> otherwise
 603    */
 604   public void setEditable(boolean flag)
 605   {
 606     if (editable == flag)
 607       return;
 608
 609     boolean oldValue = editable;
 610     editable = flag;
 611     firePropertyChange(EDITABLE_PROPERTY, oldValue, editable);
 612   }
 613
 614   /**
 615    * Checks if the root element is visible.
 616    *
 617    * @return <code>true</code> if the root element is visible,
 618    * <code>false</code> otherwise
 619    */
 620   public boolean isRootVisible()
 621   {
 622     return rootVisible;
 623   }
 624
 625   public void setRootVisible(boolean flag)
 626   {
 627     if (rootVisible == flag)
 628       return;
 629
 630     boolean oldValue = rootVisible;
 631     rootVisible = flag;
 632     firePropertyChange(ROOT_VISIBLE_PROPERTY, oldValue, flag);
 633   }
 634
 635   public boolean getShowsRootHandles()
 636   {
 637     return showsRootHandles;
 638   }
 639
 640   public void setShowsRootHandles(boolean flag)
 641   {
 642     if (showsRootHandles == flag)
 643       return;
 644
 645     boolean oldValue = showsRootHandles;
 646     showsRootHandles = flag;
 647     firePropertyChange(SHOWS_ROOT_HANDLES_PROPERTY, oldValue, flag);
 648   }
 649
 650   public TreeCellEditor getCellEditor()
 651   {
 652     return cellEditor;
 653   }
 654
 655   public void setCellEditor(TreeCellEditor editor)
 656   {
 657     if (cellEditor == editor)
 658       return;
 659
 660     TreeCellEditor oldValue = cellEditor;
 661     cellEditor = editor;
 662     firePropertyChange(CELL_EDITOR_PROPERTY, oldValue, editor);
 663   }
 664
 665   public TreeCellRenderer getCellRenderer()
 666   {
 667     return cellRenderer;
 668   }
 669
 670   public void setCellRenderer(TreeCellRenderer newRenderer)
 671   {
 672     if (cellRenderer == newRenderer)
 673       return;
 674
 675     TreeCellRenderer oldValue = cellRenderer;
 676     cellRenderer = newRenderer;
 677     firePropertyChange(CELL_RENDERER_PROPERTY, oldValue, newRenderer);
 678   }
 679
 680   public TreeSelectionModel getSelectionModel()
 681   {
 682     return selectionModel;
 683   }
 684
 685   public void setSelectionModel(TreeSelectionModel model)
 686   {
 687     if (selectionModel == model)
 688       return;
 689
 690     TreeSelectionModel oldValue = selectionModel;
 691     selectionModel = model;
 692     firePropertyChange(SELECTION_MODEL_PROPERTY, oldValue, model);
 693   }
 694
 695   public int getVisibleRowCount()
 696   {
 697     return visibleRowCount;
 698   }
 699
 700   public void setVisibleRowCount(int rows)
 701   {
 702     if (visibleRowCount == rows)
 703       return;
 704
 705     int oldValue = visibleRowCount;
 706     visibleRowCount = rows;
 707     firePropertyChange(VISIBLE_ROW_COUNT_PROPERTY, oldValue, rows);
 708   }
 709
 710   public boolean isLargeModel()
 711   {
 712     return largeModel;
 713   }
 714
 715   public void setLargeModel(boolean large)
 716   {
 717     if (largeModel == large)
 718       return;
 719
 720     boolean oldValue = largeModel;
 721     largeModel = large;
 722     firePropertyChange(LARGE_MODEL_PROPERTY, oldValue, large);
 723   }
 724
 725   public int getRowHeight()
 726   {
 727     return rowHeight;
 728   }
 729
 730   public void setRowHeight(int height)
 731   {
 732     if (rowHeight == height)
 733       return;
 734
 735     int oldValue = rowHeight;
 736     rowHeight = height;
 737     firePropertyChange(ROW_HEIGHT_PROPERTY, oldValue, height);
 738   }
 739
 740   public boolean isFixedRowHeight()
 741   {
 742     return rowHeight > 0;
 743   }
 744
 745   public boolean getInvokesStopCellEditing()
 746   {
 747     return invokesStopCellEditing;
 748   }
 749
 750   public void setInvokesStopCellEditing(boolean invoke)
 751   {
 752     if (invokesStopCellEditing == invoke)
 753      return;
 754
 755     boolean oldValue = invokesStopCellEditing;
 756     invokesStopCellEditing = invoke;
 757     firePropertyChange(INVOKES_STOP_CELL_EDITING_PROPERTY, oldValue, invoke);
 758   }
 759
 760   /**
 761    * @since 1.3
 762    */
 763   public int getToggleClickCount()
 764   {
 765     return toggleClickCount;
 766   }
 767
 768   /**
 769    * @since 1.3
 770    */
 771   public void setToggleClickCount(int count)
 772   {
 773     if (toggleClickCount == count)
 774       return;
 775
 776     int oldValue = toggleClickCount;
 777     toggleClickCount = count;
 778     firePropertyChange(TOGGLE_CLICK_COUNT_PROPERTY, oldValue, count);
 779   }
 780
 781   public void scrollPathToVisible(TreePath path)
 782   {
 783     if (path == null)
 784       return;
 785
 786     Rectangle rect = getPathBounds(path);
 787
 788     if (rect == null)
 789       return;
 790
 791     scrollRectToVisible(rect);
 792   }
 793
 794   public void scrollRowToVisible(int row)
 795   {
 796     scrollPathToVisible(getPathForRow(row));
 797   }
 798
 799   public boolean getScrollsOnExpand()
 800   {
 801     return scrollsOnExpand;
 802   }
 803
 804   public void setScrollsOnExpand(boolean scroll)
 805   {
 806     if (scrollsOnExpand == scroll)
 807       return;
 808
 809     boolean oldValue = scrollsOnExpand;
 810     scrollsOnExpand = scroll;
 811     firePropertyChange(SCROLLS_ON_EXPAND_PROPERTY, oldValue, scroll);
 812   }
 813
 814   public void setSelectionPath(TreePath path)
 815   {
 816     selectionModel.setSelectionPath(path);
 817   }
 818
 819   public void setSelectionPaths(TreePath[] paths)
 820   {
 821     selectionModel.setSelectionPaths(paths);
 822   }
 823
 824   public void setSelectionRow(int row)
 825   {
 826     TreePath path = getPathForRow(row);
 827
 828     if (path != null)
 829       selectionModel.setSelectionPath(path);
 830   }
 831
 832   public void setSelectionRows(int[] rows)
 833   {
 834     // Make sure we have an UI so getPathForRow() does not return null.
 835     if (rows == null || getUI() == null)
 836       return;
 837
 838     TreePath[] paths = new TreePath[rows.length];
 839
 840     for (int i = rows.length - 1; i >= 0; --i)
 841       paths[i] = getPathForRow(rows[i]);
 842
 843     setSelectionPaths(paths);
 844   }
 845
 846   public void setSelectionInterval(int index0, int index1)
 847   {
 848     TreePath[] paths = getPathBetweenRows(index0, index1);
 849
 850     if (paths != null)
 851       setSelectionPaths(paths);
 852   }
 853
 854   public void addSelectionPath(TreePath path)
 855   {
 856     selectionModel.addSelectionPath(path);
 857   }
 858
 859   public void addSelectionPaths(TreePath[] paths)
 860   {
 861     selectionModel.addSelectionPaths(paths);
 862   }
 863
 864   public void addSelectionRow(int row)
 865   {
 866     TreePath path = getPathForRow(row);
 867
 868     if (path != null)
 869       selectionModel.addSelectionPath(path);
 870   }
 871
 872   public void addSelectionRows(int[] rows)
 873   {
 874     // Make sure we have an UI so getPathForRow() does not return null.
 875     if (rows == null || getUI() == null)
 876       return;
 877
 878     TreePath[] paths = new TreePath[rows.length];
 879
 880     for (int i = rows.length - 1; i >= 0; --i)
 881       paths[i] = getPathForRow(rows[i]);
 882
 883     addSelectionPaths(paths);
 884   }
 885
 886   public void addSelectionInterval(int index0, int index1)
 887   {
 888     TreePath[] paths = getPathBetweenRows(index0, index1);
 889
 890     if (paths != null)
 891       addSelectionPaths(paths);
 892   }
 893
 894   public void removeSelectionPath(TreePath path)
 895   {
 896     selectionModel.removeSelectionPath(path);
 897   }
 898
 899   public void removeSelectionPaths(TreePath[] paths)
 900   {
 901     selectionModel.removeSelectionPaths(paths);
 902   }
 903
 904   public void removeSelectionRow(int row)
 905   {
 906     TreePath path = getPathForRow(row);
 907
 908     if (path != null)
 909       selectionModel.removeSelectionPath(path);
 910   }
 911
 912   public void removeSelectionRows(int[] rows)
 913   {
 914     // Make sure we have an UI so getPathForRow() does not return null.
 915     if (rows == null || getUI() == null)
 916       return;
 917
 918     TreePath[] paths = new TreePath[rows.length];
 919
 920     for (int i = rows.length - 1; i >= 0; --i)
 921       paths[i] = getPathForRow(rows[i]);
 922
 923     removeSelectionPaths(paths);
 924   }
 925
 926   public void removeSelectionInterval(int index0, int index1)
 927   {
 928     TreePath[] paths = getPathBetweenRows(index0, index1);
 929
 930     if (paths != null)
 931       removeSelectionPaths(paths);
 932   }
 933
 934   public void clearSelection()
 935   {
 936     selectionModel.clearSelection();
 937   }
 938
 939   public TreePath getLeadSelectionPath()
 940   {
 941     return leadSelectionPath;
 942   }
 943
 944   /**
 945    * @since 1.3
 946    */
 947   public void setLeadSelectionPath(TreePath path)
 948   {
 949     if (leadSelectionPath == path)
 950       return;
 951
 952     TreePath oldValue = leadSelectionPath;
 953     leadSelectionPath = path;
 954     firePropertyChange(LEAD_SELECTION_PATH_PROPERTY, oldValue, path);
 955   }
 956
 957   /**
 958    * @since 1.3
 959    */
 960   public TreePath getAnchorSelectionPath()
 961   {
 962     return anchorSelectionPath;
 963   }
 964
 965   /**
 966    * @since 1.3
 967    */
 968   public void setAnchorSelectionPath(TreePath path)
 969   {
 970     if (anchorSelectionPath == path)
 971       return;
 972
 973     TreePath oldValue = anchorSelectionPath;
 974     anchorSelectionPath = path;
 975     firePropertyChange(ANCHOR_SELECTION_PATH_PROPERTY, oldValue, path);
 976   }
 977
 978   public int getLeadSelectionRow()
 979   {
 980     return selectionModel.getLeadSelectionRow();
 981   }
 982
 983   public int getMaxSelectionRow()
 984   {
 985     return selectionModel.getMaxSelectionRow();
 986   }
 987
 988   public int getMinSelectionRow()
 989   {
 990     return selectionModel.getMinSelectionRow();
 991   }
 992
 993   public int getSelectionCount()
 994   {
 995     return selectionModel.getSelectionCount();
 996   }
 997
 998   public TreePath getSelectionPath()
 999   {
1000     return selectionModel.getSelectionPath();
1001   }
1002
1003   public TreePath[] getSelectionPaths()
1004   {
1005     return selectionModel.getSelectionPaths();
1006   }
1007
1008   public int[] getSelectionRows()
1009   {
1010     return selectionModel.getSelectionRows();
1011   }
1012
1013   public boolean isPathSelected(TreePath path)
1014   {
1015     return selectionModel.isPathSelected(path);
1016   }
1017
1018   public boolean isRowSelected(int row)
1019   {
1020     return selectionModel.isRowSelected(row);
1021   }
1022
1023   public boolean isSelectionEmpty()
1024   {
1025     return selectionModel.isSelectionEmpty();
1026   }
1027
1028   /**
1029    * Return the value of the <code>dragEnabled</code> property.
1030    *
1031    * @return the value
1032    *
1033    * @since 1.4
1034    */
1035   public boolean getDragEnabled()
1036   {
1037     return dragEnabled;
1038   }
1039
1040   /**
1041    * Set the <code>dragEnabled</code> property.
1042    *
1043    * @param enabled new value
1044    *
1045    * @since 1.4
1046    */
1047   public void setDragEnabled(boolean enabled)
1048   {
1049     dragEnabled = enabled;
1050   }
1051
1052   public int getRowCount()
1053   {
1054     TreeUI ui = getUI();
1055
1056     if (ui != null)
1057       return ui.getRowCount(this);
1058
1059     return 0;
1060   }
1061
1062   public void collapsePath(TreePath path)
1063   {
1064     setExpandedState(path, false);
1065   }
1066
1067   public void collapseRow(int row)
1068   {
1069     if (row < 0 || row >= getRowCount())
1070       return;
1071
1072     TreePath path = getPathForRow(row);
1073
1074     if (path != null)
1075       collapsePath(path);
1076   }
1077
1078   public void expandPath(TreePath path)
1079   {
1080     // Don't expand if last path component is a leaf node.
1081     if ((path == null)
1082         || (treeModel.isLeaf(path.getLastPathComponent())))
1083       return;
1084
1085     setExpandedState(path, true);
1086   }
1087
1088   public void expandRow(int row)
1089   {
1090     if (row < 0 || row >= getRowCount())
1091       return;
1092
1093     TreePath path = getPathForRow(row);
1094
1095     if (path != null)
1096       expandPath(path);
1097   }
1098
1099   public boolean isCollapsed(TreePath path)
1100   {
1101     return ! isExpanded(path);
1102   }
1103
1104   public boolean isCollapsed(int row)
1105   {
1106     if (row < 0 || row >= getRowCount())
1107       return false;
1108
1109     TreePath path = getPathForRow(row);
1110
1111     if (path != null)
1112       return isCollapsed(path);
1113
1114     return false;
1115   }
1116
1117   public boolean isExpanded(TreePath path)
1118   {
1119     if (path == null)
1120       return false;
1121
1122     Object state = nodeStates.get(path);
1123
1124     if ((state == null) || (state != EXPANDED))
1125       return false;
1126
1127     TreePath parent = path.getParentPath();
1128
1129     if (parent != null)
1130       return isExpanded(parent);
1131
1132     return true;
1133   }
1134
1135   public boolean isExpanded(int row)
1136   {
1137     if (row < 0 || row >= getRowCount())
1138       return false;
1139
1140     TreePath path = getPathForRow(row);
1141
1142     if (path != null)
1143       return isExpanded(path);
1144
1145     return false;
1146   }
1147
1148   /**
1149    * @since 1.3
1150    */
1151   public boolean getExpandsSelectedPaths()
1152   {
1153     return expandsSelectedPaths;
1154   }
1155
1156   /**
1157    * @since 1.3
1158    */
1159   public void setExpandsSelectedPaths(boolean flag)
1160   {
1161     if (expandsSelectedPaths == flag)
1162       return;
1163
1164     boolean oldValue = expandsSelectedPaths;
1165     expandsSelectedPaths = flag;
1166     firePropertyChange(EXPANDS_SELECTED_PATHS_PROPERTY, oldValue, flag);
1167   }
1168
1169   public Rectangle getPathBounds(TreePath path)
1170   {
1171     TreeUI ui = getUI();
1172
1173     if (ui == null)
1174       return null;
1175
1176     return ui.getPathBounds(this, path);
1177   }
1178
1179   public Rectangle getRowBounds(int row)
1180   {
1181     TreePath path = getPathForRow(row);
1182
1183     if (path != null)
1184       return getPathBounds(path);
1185
1186     return null;
1187   }
1188
1189   public boolean isEditing()
1190   {
1191     TreeUI ui = getUI();
1192
1193     if (ui != null)
1194       return ui.isEditing(this);
1195
1196     return false;
1197   }
1198
1199   public boolean stopEditing()
1200   {
1201     TreeUI ui = getUI();
1202
1203     if (ui != null)
1204       return ui.stopEditing(this);
1205
1206    return false;
1207   }
1208
1209   public void cancelEditing()
1210   {
1211     TreeUI ui = getUI();
1212
1213     if (ui != null)
1214       ui.cancelEditing(this);
1215   }
1216
1217   public void startEditingAtPath(TreePath path)
1218   {
1219     TreeUI ui = getUI();
1220
1221     if (ui != null)
1222       ui.startEditingAtPath(this, path);
1223   }
1224
1225   public TreePath getEditingPath()
1226   {
1227     TreeUI ui = getUI();
1228
1229     if (ui != null)
1230       return ui.getEditingPath(this);
1231
1232     return null;
1233   }
1234
1235   public TreePath getPathForLocation(int x, int y)
1236   {
1237     TreePath path = getClosestPathForLocation(x, y);
1238
1239     if (path != null)
1240       {
1241          Rectangle rect = getPathBounds(path);
1242
1243          if ((rect != null) && rect.contains(x, y))
1244            return path;
1245       }
1246
1247     return null;
1248   }
1249
1250   public int getRowForLocation(int x, int y)
1251   {
1252     TreePath path = getPathForLocation(x, y);
1253
1254     if (path != null)
1255       return getRowForPath(path);
1256
1257     return -1;
1258   }
1259
1260   public TreePath getClosestPathForLocation(int x, int y)
1261   {
1262     TreeUI ui = getUI();
1263
1264     if (ui != null)
1265       return ui.getClosestPathForLocation(this, x, y);
1266
1267     return null;
1268   }
1269
1270   public int getClosestRowForLocation(int x, int y)
1271   {
1272     TreePath path = getClosestPathForLocation(x, y);
1273
1274     if (path != null)
1275       return getRowForPath(path);
1276
1277     return -1;
1278   }
1279
1280   public Object getLastSelectedPathComponent()
1281   {
1282     TreePath path = getSelectionPath();
1283
1284     if (path != null)
1285       return path.getLastPathComponent();
1286
1287     return null;
1288   }
1289
1290   private void checkExpandParents(TreePath path)
1291     throws ExpandVetoException
1292   {
1293     TreePath parent = path.getParentPath();
1294
1295     if (parent != null)
1296       checkExpandParents(parent);
1297
1298     fireTreeWillExpand(path);
1299   }
1300
1301   private void doExpandParents(TreePath path, boolean state)
1302   {
1303     TreePath parent = path.getParentPath();
1304
1305     if (isExpanded(parent))
1306       return;
1307
1308     if (parent != null)
1309       doExpandParents(parent, false);
1310
1311     nodeStates.put(path, state ? EXPANDED : COLLAPSED);
1312   }
1313
1314   protected void setExpandedState(TreePath path, boolean state)
1315   {
1316     if (path == null)
1317       return;
1318
1319     TreePath parent = path.getParentPath();
1320
1321     try
1322       {
1323         while (parent != null)
1324           checkExpandParents(parent);
1325       }
1326     catch (ExpandVetoException e)
1327       {
1328         // Expansion vetoed.
1329         return;
1330       }
1331
1332     doExpandParents(path, state);
1333   }
1334
1335   protected void clearToggledPaths()
1336   {
1337     nodeStates.clear();
1338   }
1339
1340   protected Enumeration getDescendantToggledPaths(TreePath parent)
1341   {
1342     if (parent == null)
1343       return null;
1344
1345     Enumeration nodes = nodeStates.keys();
1346     Vector result = new Vector();
1347
1348     while (nodes.hasMoreElements())
1349       {
1350         TreePath path = (TreePath) nodes.nextElement();
1351
1352         if (path.isDescendant(parent))
1353           result.addElement(path);
1354       }
1355
1356     return result.elements();
1357   }
1358
1359   public boolean hasBeenExpanded(TreePath path)
1360   {
1361     if (path == null)
1362       return false;
1363
1364     return nodeStates.get(path) != null;
1365   }
1366
1367   public boolean isVisible(TreePath path)
1368   {
1369     if (path == null)
1370       return false;
1371
1372     TreePath parent = path.getParentPath();
1373
1374     if (parent == null)
1375       return true; // Is root node.
1376
1377     return isExpanded(parent);
1378   }
1379
1380   public void makeVisible(TreePath path)
1381   {
1382     if (path == null)
1383       return;
1384
1385     expandPath(path.getParentPath());
1386   }
1387
1388   public boolean isPathEditable(TreePath path)
1389   {
1390     return isEditable();
1391   }
1392 }