1 /*
   2  * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package javax.swing.tree;
  26 
  27 import javax.swing.event.TreeModelEvent;
  28 import java.awt.Rectangle;
  29 import java.beans.BeanProperty;
  30 import java.util.Enumeration;
  31 import java.util.Hashtable;
  32 import java.util.NoSuchElementException;
  33 import java.util.Stack;
  34 import java.util.Vector;
  35 
  36 import sun.swing.SwingUtilities2;
  37 
  38 /**
  39  * NOTE: This will become more open in a future release.
  40  * <p>
  41  * <strong>Warning:</strong>
  42  * Serialized objects of this class will not be compatible with
  43  * future Swing releases. The current serialization support is
  44  * appropriate for short term storage or RMI between applications running
  45  * the same version of Swing.  As of 1.4, support for long term storage
  46  * of all JavaBeans&trade;
  47  * has been added to the <code>java.beans</code> package.
  48  * Please see {@link java.beans.XMLEncoder}.
  49  *
  50  * @author Rob Davis
  51  * @author Ray Ryan
  52  * @author Scott Violet
  53  */
  54 @SuppressWarnings("serial") // Same-version serialization only
  55 public class VariableHeightLayoutCache extends AbstractLayoutCache {
  56     /**
  57      * The array of nodes that are currently visible, in the order they
  58      * are displayed.
  59      */
  60     private Vector<Object> visibleNodes;
  61 
  62     /**
  63      * This is set to true if one of the entries has an invalid size.
  64      */
  65     private boolean           updateNodeSizes;
  66 
  67     /**
  68      * The root node of the internal cache of nodes that have been shown.
  69      * If the treeModel is vending a network rather than a true tree,
  70      * there may be one cached node for each path to a modeled node.
  71      */
  72     private TreeStateNode     root;
  73 
  74     /**
  75      * Used in getting sizes for nodes to avoid creating a new Rectangle
  76      * every time a size is needed.
  77      */
  78     private Rectangle         boundsBuffer;
  79 
  80     /**
  81      * Maps from <code>TreePath</code> to a <code>TreeStateNode</code>.
  82      */
  83     private Hashtable<TreePath, TreeStateNode> treePathMapping;
  84 
  85     /**
  86      * A stack of stacks.
  87      */
  88     private Stack<Stack<TreePath>> tempStacks;
  89 
  90 
  91     /**
  92      * Constructs a {@code VariableHeightLayoutCache}.
  93      */
  94     public VariableHeightLayoutCache() {
  95         super();
  96         tempStacks = new Stack<Stack<TreePath>>();
  97         visibleNodes = new Vector<Object>();
  98         boundsBuffer = new Rectangle();
  99         treePathMapping = new Hashtable<TreePath, TreeStateNode>();
 100     }
 101 
 102     /**
 103      * Sets the <code>TreeModel</code> that will provide the data.
 104      *
 105      * @param newModel the <code>TreeModel</code> that is to provide the data
 106      */
 107     @BeanProperty(description
 108             = "The TreeModel that will provide the data.")
 109     public void setModel(TreeModel newModel) {
 110         super.setModel(newModel);
 111         rebuild(false);
 112     }
 113 
 114     /**
 115      * Determines whether or not the root node from
 116      * the <code>TreeModel</code> is visible.
 117      *
 118      * @param rootVisible true if the root node of the tree is to be displayed
 119      * @see #rootVisible
 120      */
 121     @BeanProperty(description
 122             = "Whether or not the root node from the TreeModel is visible.")
 123     public void setRootVisible(boolean rootVisible) {
 124         if(isRootVisible() != rootVisible && root != null) {
 125             if(rootVisible) {
 126                 root.updatePreferredSize(0);
 127                 visibleNodes.insertElementAt(root, 0);
 128             }
 129             else if(visibleNodes.size() > 0) {
 130                 visibleNodes.removeElementAt(0);
 131                 if(treeSelectionModel != null)
 132                     treeSelectionModel.removeSelectionPath
 133                         (root.getTreePath());
 134             }
 135             if(treeSelectionModel != null)
 136                 treeSelectionModel.resetRowSelection();
 137             if(getRowCount() > 0)
 138                 getNode(0).setYOrigin(0);
 139             updateYLocationsFrom(0);
 140             visibleNodesChanged();
 141         }
 142         super.setRootVisible(rootVisible);
 143     }
 144 
 145     /**
 146      * Sets the height of each cell.  If the specified value
 147      * is less than or equal to zero the current cell renderer is
 148      * queried for each row's height.
 149      *
 150      * @param rowHeight the height of each cell, in pixels
 151      */
 152     @BeanProperty(description
 153             = "The height of each cell.")
 154     public void setRowHeight(int rowHeight) {
 155         if(rowHeight != getRowHeight()) {
 156             super.setRowHeight(rowHeight);
 157             invalidateSizes();
 158             this.visibleNodesChanged();
 159         }
 160     }
 161 
 162     /**
 163      * Sets the renderer that is responsible for drawing nodes in the tree.
 164      * @param nd the renderer
 165      */
 166     public void setNodeDimensions(NodeDimensions nd) {
 167         super.setNodeDimensions(nd);
 168         invalidateSizes();
 169         visibleNodesChanged();
 170     }
 171 
 172     /**
 173      * Marks the path <code>path</code> expanded state to
 174      * <code>isExpanded</code>.
 175      * @param path the <code>TreePath</code> of interest
 176      * @param isExpanded true if the path should be expanded, otherwise false
 177      */
 178     public void setExpandedState(TreePath path, boolean isExpanded) {
 179         if(path != null) {
 180             if(isExpanded)
 181                 ensurePathIsExpanded(path, true);
 182             else {
 183                 TreeStateNode        node = getNodeForPath(path, false, true);
 184 
 185                 if(node != null) {
 186                     node.makeVisible();
 187                     node.collapse();
 188                 }
 189             }
 190         }
 191     }
 192 
 193     /**
 194      * Returns true if the path is expanded, and visible.
 195      * @return true if the path is expanded and visible, otherwise false
 196      */
 197     public boolean getExpandedState(TreePath path) {
 198         TreeStateNode       node = getNodeForPath(path, true, false);
 199 
 200         return (node != null) ? (node.isVisible() && node.isExpanded()) :
 201                                  false;
 202     }
 203 
 204     /**
 205       * Returns the <code>Rectangle</code> enclosing the label portion
 206       * into which the item identified by <code>path</code> will be drawn.
 207       *
 208       * @param path  the path to be drawn
 209       * @param placeIn the bounds of the enclosing rectangle
 210       * @return the bounds of the enclosing rectangle or <code>null</code>
 211       *    if the node could not be ascertained
 212       */
 213     public Rectangle getBounds(TreePath path, Rectangle placeIn) {
 214         TreeStateNode       node = getNodeForPath(path, true, false);
 215 
 216         if(node != null) {
 217             if(updateNodeSizes)
 218                 updateNodeSizes(false);
 219             return node.getNodeBounds(placeIn);
 220         }
 221         return null;
 222     }
 223 
 224     /**
 225       * Returns the path for <code>row</code>.  If <code>row</code>
 226       * is not visible, <code>null</code> is returned.
 227       *
 228       * @param row the location of interest
 229       * @return the path for <code>row</code>, or <code>null</code>
 230       * if <code>row</code> is not visible
 231       */
 232     public TreePath getPathForRow(int row) {
 233         if(row >= 0 && row < getRowCount()) {
 234             return getNode(row).getTreePath();
 235         }
 236         return null;
 237     }
 238 
 239     /**
 240       * Returns the row where the last item identified in path is visible.
 241       * Will return -1 if any of the elements in path are not
 242       * currently visible.
 243       *
 244       * @param path the <code>TreePath</code> of interest
 245       * @return the row where the last item in path is visible
 246       */
 247     public int getRowForPath(TreePath path) {
 248         if(path == null)
 249             return -1;
 250 
 251         TreeStateNode    visNode = getNodeForPath(path, true, false);
 252 
 253         if(visNode != null)
 254             return visNode.getRow();
 255         return -1;
 256     }
 257 
 258     /**
 259      * Returns the number of visible rows.
 260      * @return the number of visible rows
 261      */
 262     public int getRowCount() {
 263         return visibleNodes.size();
 264     }
 265 
 266     /**
 267      * Instructs the <code>LayoutCache</code> that the bounds for
 268      * <code>path</code> are invalid, and need to be updated.
 269      *
 270      * @param path the <code>TreePath</code> which is now invalid
 271      */
 272     public void invalidatePathBounds(TreePath path) {
 273         TreeStateNode       node = getNodeForPath(path, true, false);
 274 
 275         if(node != null) {
 276             node.markSizeInvalid();
 277             if(node.isVisible())
 278                 updateYLocationsFrom(node.getRow());
 279         }
 280     }
 281 
 282     /**
 283      * Returns the preferred height.
 284      * @return the preferred height
 285      */
 286     public int getPreferredHeight() {
 287         // Get the height
 288         int           rowCount = getRowCount();
 289 
 290         if(rowCount > 0) {
 291             TreeStateNode  node = getNode(rowCount - 1);
 292 
 293             return node.getYOrigin() + node.getPreferredHeight();
 294         }
 295         return 0;
 296     }
 297 
 298     /**
 299      * Returns the preferred width and height for the region in
 300      * <code>visibleRegion</code>.
 301      *
 302      * @param bounds  the region being queried
 303      */
 304     public int getPreferredWidth(Rectangle bounds) {
 305         if(updateNodeSizes)
 306             updateNodeSizes(false);
 307 
 308         return getMaxNodeWidth();
 309     }
 310 
 311     /**
 312       * Returns the path to the node that is closest to x,y.  If
 313       * there is nothing currently visible this will return <code>null</code>,
 314       * otherwise it will always return a valid path.
 315       * If you need to test if the
 316       * returned object is exactly at x, y you should get the bounds for
 317       * the returned path and test x, y against that.
 318       *
 319       * @param x  the x-coordinate
 320       * @param y  the y-coordinate
 321       * @return the path to the node that is closest to x, y
 322       */
 323     public TreePath getPathClosestTo(int x, int y) {
 324         if(getRowCount() == 0)
 325             return null;
 326 
 327         if(updateNodeSizes)
 328             updateNodeSizes(false);
 329 
 330         int                row = getRowContainingYLocation(y);
 331 
 332         return getNode(row).getTreePath();
 333     }
 334 
 335     /**
 336      * Returns an <code>Enumerator</code> that increments over the visible paths
 337      * starting at the passed in location. The ordering of the enumeration
 338      * is based on how the paths are displayed.
 339      *
 340      * @param path the location in the <code>TreePath</code> to start
 341      * @return an <code>Enumerator</code> that increments over the visible
 342      *     paths
 343      */
 344     public Enumeration<TreePath> getVisiblePathsFrom(TreePath path) {
 345         TreeStateNode       node = getNodeForPath(path, true, false);
 346 
 347         if(node != null) {
 348             return new VisibleTreeStateNodeEnumeration(node);
 349         }
 350         return null;
 351     }
 352 
 353     /**
 354      * Returns the number of visible children for <code>path</code>.
 355      * @return the number of visible children for <code>path</code>
 356      */
 357     public int getVisibleChildCount(TreePath path) {
 358         TreeStateNode         node = getNodeForPath(path, true, false);
 359 
 360         return (node != null) ? node.getVisibleChildCount() : 0;
 361     }
 362 
 363     /**
 364      * Informs the <code>TreeState</code> that it needs to recalculate
 365      * all the sizes it is referencing.
 366      */
 367     public void invalidateSizes() {
 368         if(root != null)
 369             root.deepMarkSizeInvalid();
 370         if(!isFixedRowHeight() && visibleNodes.size() > 0) {
 371             updateNodeSizes(true);
 372         }
 373     }
 374 
 375     /**
 376       * Returns true if the value identified by <code>path</code> is
 377       * currently expanded.
 378       * @return true if the value identified by <code>path</code> is
 379       *    currently expanded
 380       */
 381     public boolean isExpanded(TreePath path) {
 382         if(path != null) {
 383             TreeStateNode     lastNode = getNodeForPath(path, true, false);
 384 
 385             return (lastNode != null && lastNode.isExpanded());
 386         }
 387         return false;
 388     }
 389 
 390     //
 391     // TreeModelListener methods
 392     //
 393 
 394     /**
 395      * Invoked after a node (or a set of siblings) has changed in some
 396      * way. The node(s) have not changed locations in the tree or
 397      * altered their children arrays, but other attributes have
 398      * changed and may affect presentation. Example: the name of a
 399      * file has changed, but it is in the same location in the file
 400      * system.
 401      *
 402      * <p><code>e.path</code> returns the path the parent of the
 403      * changed node(s).
 404      *
 405      * <p><code>e.childIndices</code> returns the index(es) of the
 406      * changed node(s).
 407      *
 408      * @param e the <code>TreeModelEvent</code> of interest
 409      */
 410     public void treeNodesChanged(TreeModelEvent e) {
 411         if(e != null) {
 412             int               changedIndexs[];
 413             TreeStateNode     changedNode;
 414 
 415             changedIndexs = e.getChildIndices();
 416             changedNode = getNodeForPath(SwingUtilities2.getTreePath(e, getModel()), false, false);
 417             if(changedNode != null) {
 418                 Object            changedValue = changedNode.getValue();
 419 
 420                 /* Update the size of the changed node, as well as all the
 421                    child indexs that are passed in. */
 422                 changedNode.updatePreferredSize();
 423                 if(changedNode.hasBeenExpanded() && changedIndexs != null) {
 424                     int                counter;
 425                     TreeStateNode      changedChildNode;
 426 
 427                     for(counter = 0; counter < changedIndexs.length;
 428                         counter++) {
 429                         changedChildNode = (TreeStateNode)changedNode
 430                                     .getChildAt(changedIndexs[counter]);
 431                         /* Reset the user object. */
 432                         changedChildNode.setUserObject
 433                                     (treeModel.getChild(changedValue,
 434                                                      changedIndexs[counter]));
 435                         changedChildNode.updatePreferredSize();
 436                     }
 437                 }
 438                 else if (changedNode == root) {
 439                     // Null indicies for root indicates it changed.
 440                     changedNode.updatePreferredSize();
 441                 }
 442                 if(!isFixedRowHeight()) {
 443                     int          aRow = changedNode.getRow();
 444 
 445                     if(aRow != -1)
 446                         this.updateYLocationsFrom(aRow);
 447                 }
 448                 this.visibleNodesChanged();
 449             }
 450         }
 451     }
 452 
 453 
 454     /**
 455      * Invoked after nodes have been inserted into the tree.
 456      *
 457      * <p><code>e.path</code> returns the parent of the new nodes.
 458      * <p><code>e.childIndices</code> returns the indices of the new nodes in
 459      * ascending order.
 460      *
 461      * @param e the <code>TreeModelEvent</code> of interest
 462      */
 463     public void treeNodesInserted(TreeModelEvent e) {
 464         if(e != null) {
 465             int               changedIndexs[];
 466             TreeStateNode     changedParentNode;
 467 
 468             changedIndexs = e.getChildIndices();
 469             changedParentNode = getNodeForPath(SwingUtilities2.getTreePath(e, getModel()), false, false);
 470             /* Only need to update the children if the node has been
 471                expanded once. */
 472             // PENDING(scott): make sure childIndexs is sorted!
 473             if(changedParentNode != null && changedIndexs != null &&
 474                changedIndexs.length > 0) {
 475                 if(changedParentNode.hasBeenExpanded()) {
 476                     boolean            makeVisible;
 477                     int                counter;
 478                     Object             changedParent;
 479                     TreeStateNode      newNode;
 480                     int                oldChildCount = changedParentNode.
 481                                           getChildCount();
 482 
 483                     changedParent = changedParentNode.getValue();
 484                     makeVisible = ((changedParentNode == root &&
 485                                     !rootVisible) ||
 486                                    (changedParentNode.getRow() != -1 &&
 487                                     changedParentNode.isExpanded()));
 488                     for(counter = 0;counter < changedIndexs.length;counter++)
 489                     {
 490                         newNode = this.createNodeAt(changedParentNode,
 491                                                     changedIndexs[counter]);
 492                     }
 493                     if(oldChildCount == 0) {
 494                         // Update the size of the parent.
 495                         changedParentNode.updatePreferredSize();
 496                     }
 497                     if(treeSelectionModel != null)
 498                         treeSelectionModel.resetRowSelection();
 499                     /* Update the y origins from the index of the parent
 500                        to the end of the visible rows. */
 501                     if(!isFixedRowHeight() && (makeVisible ||
 502                                                (oldChildCount == 0 &&
 503                                         changedParentNode.isVisible()))) {
 504                         if(changedParentNode == root)
 505                             this.updateYLocationsFrom(0);
 506                         else
 507                             this.updateYLocationsFrom(changedParentNode.
 508                                                       getRow());
 509                         this.visibleNodesChanged();
 510                     }
 511                     else if(makeVisible)
 512                         this.visibleNodesChanged();
 513                 }
 514                 else if(treeModel.getChildCount(changedParentNode.getValue())
 515                         - changedIndexs.length == 0) {
 516                     changedParentNode.updatePreferredSize();
 517                     if(!isFixedRowHeight() && changedParentNode.isVisible())
 518                         updateYLocationsFrom(changedParentNode.getRow());
 519                 }
 520             }
 521         }
 522     }
 523 
 524     /**
 525      * Invoked after nodes have been removed from the tree.  Note that
 526      * if a subtree is removed from the tree, this method may only be
 527      * invoked once for the root of the removed subtree, not once for
 528      * each individual set of siblings removed.
 529      *
 530      * <p><code>e.path</code> returns the former parent of the deleted nodes.
 531      *
 532      * <p><code>e.childIndices</code> returns the indices the nodes had
 533      * before they were deleted in ascending order.
 534      *
 535      * @param e the <code>TreeModelEvent</code> of interest
 536      */
 537     public void treeNodesRemoved(TreeModelEvent e) {
 538         if(e != null) {
 539             int               changedIndexs[];
 540             TreeStateNode     changedParentNode;
 541 
 542             changedIndexs = e.getChildIndices();
 543             changedParentNode = getNodeForPath(SwingUtilities2.getTreePath(e, getModel()), false, false);
 544             // PENDING(scott): make sure that changedIndexs are sorted in
 545             // ascending order.
 546             if(changedParentNode != null && changedIndexs != null &&
 547                changedIndexs.length > 0) {
 548                 if(changedParentNode.hasBeenExpanded()) {
 549                     boolean            makeInvisible;
 550                     int                counter;
 551                     int                removedRow;
 552                     TreeStateNode      removedNode;
 553 
 554                     makeInvisible = ((changedParentNode == root &&
 555                                       !rootVisible) ||
 556                                      (changedParentNode.getRow() != -1 &&
 557                                       changedParentNode.isExpanded()));
 558                     for(counter = changedIndexs.length - 1;counter >= 0;
 559                         counter--) {
 560                         removedNode = (TreeStateNode)changedParentNode.
 561                                 getChildAt(changedIndexs[counter]);
 562                         if(removedNode.isExpanded()) {
 563                             removedNode.collapse(false);
 564                         }
 565 
 566                         /* Let the selection model now. */
 567                         if(makeInvisible) {
 568                             removedRow = removedNode.getRow();
 569                             if(removedRow != -1) {
 570                                 visibleNodes.removeElementAt(removedRow);
 571                             }
 572                         }
 573                         changedParentNode.remove(changedIndexs[counter]);
 574                     }
 575                     if(changedParentNode.getChildCount() == 0) {
 576                         // Update the size of the parent.
 577                         changedParentNode.updatePreferredSize();
 578                         if (changedParentNode.isExpanded() &&
 579                                    changedParentNode.isLeaf()) {
 580                             // Node has become a leaf, collapse it.
 581                             changedParentNode.collapse(false);
 582                         }
 583                     }
 584                     if(treeSelectionModel != null)
 585                         treeSelectionModel.resetRowSelection();
 586                     /* Update the y origins from the index of the parent
 587                        to the end of the visible rows. */
 588                     if(!isFixedRowHeight() && (makeInvisible ||
 589                                (changedParentNode.getChildCount() == 0 &&
 590                                 changedParentNode.isVisible()))) {
 591                         if(changedParentNode == root) {
 592                             /* It is possible for first row to have been
 593                                removed if the root isn't visible, in which
 594                                case ylocations will be off! */
 595                             if(getRowCount() > 0)
 596                                 getNode(0).setYOrigin(0);
 597                             updateYLocationsFrom(0);
 598                         }
 599                         else
 600                             updateYLocationsFrom(changedParentNode.getRow());
 601                         this.visibleNodesChanged();
 602                     }
 603                     else if(makeInvisible)
 604                         this.visibleNodesChanged();
 605                 }
 606                 else if(treeModel.getChildCount(changedParentNode.getValue())
 607                         == 0) {
 608                     changedParentNode.updatePreferredSize();
 609                     if(!isFixedRowHeight() && changedParentNode.isVisible())
 610                         this.updateYLocationsFrom(changedParentNode.getRow());
 611                 }
 612             }
 613         }
 614     }
 615 
 616     /**
 617      * Invoked after the tree has drastically changed structure from a
 618      * given node down.  If the path returned by <code>e.getPath</code>
 619      * is of length one and the first element does not identify the
 620      * current root node the first element should become the new root
 621      * of the tree.
 622      *
 623      * <p><code>e.path</code> holds the path to the node.
 624      * <p><code>e.childIndices</code> returns <code>null</code>.
 625      *
 626      * @param e the <code>TreeModelEvent</code> of interest
 627      */
 628     public void treeStructureChanged(TreeModelEvent e) {
 629         if(e != null)
 630         {
 631             TreePath          changedPath = SwingUtilities2.getTreePath(e, getModel());
 632             TreeStateNode     changedNode;
 633 
 634             changedNode = getNodeForPath(changedPath, false, false);
 635 
 636             // Check if root has changed, either to a null root, or
 637             // to an entirely new root.
 638             if(changedNode == root ||
 639                (changedNode == null &&
 640                 ((changedPath == null && treeModel != null &&
 641                   treeModel.getRoot() == null) ||
 642                  (changedPath != null && changedPath.getPathCount() == 1)))) {
 643                 rebuild(true);
 644             }
 645             else if(changedNode != null) {
 646                 int                              nodeIndex, oldRow;
 647                 TreeStateNode                    newNode, parent;
 648                 boolean                          wasExpanded, wasVisible;
 649                 int                              newIndex;
 650 
 651                 wasExpanded = changedNode.isExpanded();
 652                 wasVisible = (changedNode.getRow() != -1);
 653                 /* Remove the current node and recreate a new one. */
 654                 parent = (TreeStateNode)changedNode.getParent();
 655                 nodeIndex = parent.getIndex(changedNode);
 656                 if(wasVisible && wasExpanded) {
 657                     changedNode.collapse(false);
 658                 }
 659                 if(wasVisible)
 660                     visibleNodes.removeElement(changedNode);
 661                 changedNode.removeFromParent();
 662                 createNodeAt(parent, nodeIndex);
 663                 newNode = (TreeStateNode)parent.getChildAt(nodeIndex);
 664                 if(wasVisible && wasExpanded)
 665                     newNode.expand(false);
 666                 newIndex = newNode.getRow();
 667                 if(!isFixedRowHeight() && wasVisible) {
 668                     if(newIndex == 0)
 669                         updateYLocationsFrom(newIndex);
 670                     else
 671                         updateYLocationsFrom(newIndex - 1);
 672                     this.visibleNodesChanged();
 673                 }
 674                 else if(wasVisible)
 675                     this.visibleNodesChanged();
 676             }
 677         }
 678     }
 679 
 680 
 681     //
 682     // Local methods
 683     //
 684 
 685     private void visibleNodesChanged() {
 686     }
 687 
 688     /**
 689      * Adds a mapping for node.
 690      */
 691     private void addMapping(TreeStateNode node) {
 692         treePathMapping.put(node.getTreePath(), node);
 693     }
 694 
 695     /**
 696      * Removes the mapping for a previously added node.
 697      */
 698     private void removeMapping(TreeStateNode node) {
 699         treePathMapping.remove(node.getTreePath());
 700     }
 701 
 702     /**
 703      * Returns the node previously added for <code>path</code>. This may
 704      * return null, if you to create a node use getNodeForPath.
 705      */
 706     private TreeStateNode getMapping(TreePath path) {
 707         return treePathMapping.get(path);
 708     }
 709 
 710     /**
 711      * Retursn the bounds for row, <code>row</code> by reference in
 712      * <code>placeIn</code>. If <code>placeIn</code> is null a new
 713      * Rectangle will be created and returned.
 714      */
 715     private Rectangle getBounds(int row, Rectangle placeIn) {
 716         if(updateNodeSizes)
 717             updateNodeSizes(false);
 718 
 719         if(row >= 0 && row < getRowCount()) {
 720             return getNode(row).getNodeBounds(placeIn);
 721         }
 722         return null;
 723     }
 724 
 725     /**
 726      * Completely rebuild the tree, all expanded state, and node caches are
 727      * removed. All nodes are collapsed, except the root.
 728      */
 729     private void rebuild(boolean clearSelection) {
 730         Object rootObject;
 731 
 732         treePathMapping.clear();
 733         if(treeModel != null && (rootObject = treeModel.getRoot()) != null) {
 734             root = createNodeForValue(rootObject);
 735             root.path = new TreePath(rootObject);
 736             addMapping(root);
 737             root.updatePreferredSize(0);
 738             visibleNodes.removeAllElements();
 739             if (isRootVisible())
 740                 visibleNodes.addElement(root);
 741             if(!root.isExpanded())
 742                 root.expand();
 743             else {
 744                 Enumeration<?> cursor = root.children();
 745                 while(cursor.hasMoreElements()) {
 746                     visibleNodes.addElement(cursor.nextElement());
 747                 }
 748                 if(!isFixedRowHeight())
 749                     updateYLocationsFrom(0);
 750             }
 751         }
 752         else {
 753             visibleNodes.removeAllElements();
 754             root = null;
 755         }
 756         if(clearSelection && treeSelectionModel != null) {
 757             treeSelectionModel.clearSelection();
 758         }
 759         this.visibleNodesChanged();
 760     }
 761 
 762     /**
 763       * Creates a new node to represent the node at <I>childIndex</I> in
 764       * <I>parent</I>s children.  This should be called if the node doesn't
 765       * already exist and <I>parent</I> has been expanded at least once.
 766       * The newly created node will be made visible if <I>parent</I> is
 767       * currently expanded.  This does not update the position of any
 768       * cells, nor update the selection if it needs to be.  If succesful
 769       * in creating the new TreeStateNode, it is returned, otherwise
 770       * null is returned.
 771       */
 772     private TreeStateNode createNodeAt(TreeStateNode parent,
 773                                          int childIndex) {
 774         boolean                isParentRoot;
 775         Object                 newValue;
 776         TreeStateNode          newChildNode;
 777 
 778         newValue = treeModel.getChild(parent.getValue(), childIndex);
 779         newChildNode = createNodeForValue(newValue);
 780         parent.insert(newChildNode, childIndex);
 781         newChildNode.updatePreferredSize(-1);
 782         isParentRoot = (parent == root);
 783         if(newChildNode != null && parent.isExpanded() &&
 784            (parent.getRow() != -1 || isParentRoot)) {
 785             int                 newRow;
 786 
 787             /* Find the new row to insert this newly visible node at. */
 788             if(childIndex == 0) {
 789                 if(isParentRoot && !isRootVisible())
 790                     newRow = 0;
 791                 else
 792                     newRow = parent.getRow() + 1;
 793             }
 794             else if(childIndex == parent.getChildCount())
 795                 newRow = parent.getLastVisibleNode().getRow() + 1;
 796             else {
 797                 TreeStateNode          previousNode;
 798 
 799                 previousNode = (TreeStateNode)parent.
 800                     getChildAt(childIndex - 1);
 801                 newRow = previousNode.getLastVisibleNode().getRow() + 1;
 802             }
 803             visibleNodes.insertElementAt(newChildNode, newRow);
 804         }
 805         return newChildNode;
 806     }
 807 
 808     /**
 809       * Returns the TreeStateNode identified by path.  This mirrors
 810       * the behavior of getNodeForPath, but tries to take advantage of
 811       * path if it is an instance of AbstractTreePath.
 812       */
 813     private TreeStateNode getNodeForPath(TreePath path,
 814                                            boolean onlyIfVisible,
 815                                            boolean shouldCreate) {
 816         if(path != null) {
 817             TreeStateNode      node;
 818 
 819             node = getMapping(path);
 820             if(node != null) {
 821                 if(onlyIfVisible && !node.isVisible())
 822                     return null;
 823                 return node;
 824             }
 825 
 826             // Check all the parent paths, until a match is found.
 827             Stack<TreePath> paths;
 828 
 829             if(tempStacks.size() == 0) {
 830                 paths = new Stack<TreePath>();
 831             }
 832             else {
 833                 paths = tempStacks.pop();
 834             }
 835 
 836             try {
 837                 paths.push(path);
 838                 path = path.getParentPath();
 839                 node = null;
 840                 while(path != null) {
 841                     node = getMapping(path);
 842                     if(node != null) {
 843                         // Found a match, create entries for all paths in
 844                         // paths.
 845                         while(node != null && paths.size() > 0) {
 846                             path = paths.pop();
 847                             node.getLoadedChildren(shouldCreate);
 848 
 849                             int            childIndex = treeModel.
 850                                       getIndexOfChild(node.getUserObject(),
 851                                                   path.getLastPathComponent());
 852 
 853                             if(childIndex == -1 ||
 854                                childIndex >= node.getChildCount() ||
 855                                (onlyIfVisible && !node.isVisible())) {
 856                                 node = null;
 857                             }
 858                             else
 859                                 node = (TreeStateNode)node.getChildAt
 860                                                (childIndex);
 861                         }
 862                         return node;
 863                     }
 864                     paths.push(path);
 865                     path = path.getParentPath();
 866                 }
 867             }
 868             finally {
 869                 paths.removeAllElements();
 870                 tempStacks.push(paths);
 871             }
 872             // If we get here it means they share a different root!
 873             // We could throw an exception...
 874         }
 875         return null;
 876     }
 877 
 878     /**
 879       * Updates the y locations of all of the visible nodes after
 880       * location.
 881       */
 882     private void updateYLocationsFrom(int location) {
 883         if(location >= 0 && location < getRowCount()) {
 884             int                    counter, maxCounter, newYOrigin;
 885             TreeStateNode          aNode;
 886 
 887             aNode = getNode(location);
 888             newYOrigin = aNode.getYOrigin() + aNode.getPreferredHeight();
 889             for(counter = location + 1, maxCounter = visibleNodes.size();
 890                 counter < maxCounter;counter++) {
 891                 aNode = (TreeStateNode)visibleNodes.
 892                     elementAt(counter);
 893                 aNode.setYOrigin(newYOrigin);
 894                 newYOrigin += aNode.getPreferredHeight();
 895             }
 896         }
 897     }
 898 
 899     /**
 900       * Resets the y origin of all the visible nodes as well as messaging
 901       * all the visible nodes to updatePreferredSize().  You should not
 902       * normally have to call this.  Expanding and contracting the nodes
 903       * automaticly adjusts the locations.
 904       * updateAll determines if updatePreferredSize() is call on all nodes
 905       * or just those that don't have a valid size.
 906       */
 907     private void updateNodeSizes(boolean updateAll) {
 908         int                      aY, counter, maxCounter;
 909         TreeStateNode            node;
 910 
 911         updateNodeSizes = false;
 912         for(aY = counter = 0, maxCounter = visibleNodes.size();
 913             counter < maxCounter; counter++) {
 914             node = (TreeStateNode)visibleNodes.elementAt(counter);
 915             node.setYOrigin(aY);
 916             if(updateAll || !node.hasValidSize())
 917                 node.updatePreferredSize(counter);
 918             aY += node.getPreferredHeight();
 919         }
 920     }
 921 
 922     /**
 923       * Returns the index of the row containing location.  If there
 924       * are no rows, -1 is returned.  If location is beyond the last
 925       * row index, the last row index is returned.
 926       */
 927     private int getRowContainingYLocation(int location) {
 928 
 929         if(getRowCount() == 0)
 930             return -1;
 931         if(isFixedRowHeight()) {
 932             return Math.max(0, Math.min(getRowCount() - 1,
 933                                         location / getRowHeight()));
 934         }
 935 
 936         int max = getRowCount(), min = 0, mid = 0;
 937 
 938         while(min < max) {
 939             mid = (max - min) / 2 + min;
 940             TreeStateNode node = (TreeStateNode)visibleNodes.elementAt(mid);
 941             int minY = node.getYOrigin();
 942             int maxY = minY + node.getPreferredHeight();
 943             if(location < minY) {
 944                 max = mid - 1;
 945             }
 946             else if(location >= maxY) {
 947                 min = mid + 1;
 948             }
 949             else
 950                 break;
 951         }
 952         if(min == max) {
 953             mid = min;
 954             if(mid >= getRowCount())
 955                 mid = getRowCount() - 1;
 956         }
 957         return mid;
 958     }
 959 
 960     /**
 961      * Ensures that all the path components in path are expanded, accept
 962      * for the last component which will only be expanded if expandLast
 963      * is true.
 964      * Returns true if succesful in finding the path.
 965      */
 966     private void ensurePathIsExpanded(TreePath aPath, boolean expandLast) {
 967         if(aPath != null) {
 968             // Make sure the last entry isn't a leaf.
 969             if(treeModel.isLeaf(aPath.getLastPathComponent())) {
 970                 aPath = aPath.getParentPath();
 971                 expandLast = true;
 972             }
 973             if(aPath != null) {
 974                 TreeStateNode     lastNode = getNodeForPath(aPath, false,
 975                                                             true);
 976 
 977                 if(lastNode != null) {
 978                     lastNode.makeVisible();
 979                     if(expandLast)
 980                         lastNode.expand();
 981                 }
 982             }
 983         }
 984     }
 985 
 986     /**
 987      * Returns the AbstractTreeUI.VisibleNode displayed at the given row
 988      */
 989     private TreeStateNode getNode(int row) {
 990         return (TreeStateNode)visibleNodes.elementAt(row);
 991     }
 992 
 993     /**
 994       * Returns the maximum node width.
 995       */
 996     private int getMaxNodeWidth() {
 997 
 998         return visibleNodes.stream().reduce(0,(a,b) -> {
 999             TreeStateNode node = (TreeStateNode)b;
1000             return Math.max(a, node.getPreferredWidth() + node.getXOrigin());
1001         }, Math::max);
1002     }
1003 
1004     /**
1005       * Responsible for creating a TreeStateNode that will be used
1006       * to track display information about value.
1007       */
1008     private TreeStateNode createNodeForValue(Object value) {
1009         return new TreeStateNode(value);
1010     }
1011 
1012 
1013     /**
1014      * TreeStateNode is used to keep track of each of
1015      * the nodes that have been expanded. This will also cache the preferred
1016      * size of the value it represents.
1017      */
1018     private class TreeStateNode extends DefaultMutableTreeNode {
1019         /** Preferred size needed to draw the user object. */
1020         protected int             preferredWidth;
1021         protected int             preferredHeight;
1022 
1023         /** X location that the user object will be drawn at. */
1024         protected int             xOrigin;
1025 
1026         /** Y location that the user object will be drawn at. */
1027         protected int             yOrigin;
1028 
1029         /** Is this node currently expanded? */
1030         protected boolean         expanded;
1031 
1032         /** Has this node been expanded at least once? */
1033         protected boolean         hasBeenExpanded;
1034 
1035         /** Path of this node. */
1036         protected TreePath        path;
1037 
1038 
1039         public TreeStateNode(Object value) {
1040             super(value);
1041         }
1042 
1043         //
1044         // Overriden DefaultMutableTreeNode methods
1045         //
1046 
1047         /**
1048          * Messaged when this node is added somewhere, resets the path
1049          * and adds a mapping from path to this node.
1050          */
1051         public void setParent(MutableTreeNode parent) {
1052             super.setParent(parent);
1053             if(parent != null) {
1054                 path = ((TreeStateNode)parent).getTreePath().
1055                                        pathByAddingChild(getUserObject());
1056                 addMapping(this);
1057             }
1058         }
1059 
1060         /**
1061          * Messaged when this node is removed from its parent, this messages
1062          * <code>removedFromMapping</code> to remove all the children.
1063          */
1064         public void remove(int childIndex) {
1065             TreeStateNode     node = (TreeStateNode)getChildAt(childIndex);
1066 
1067             node.removeFromMapping();
1068             super.remove(childIndex);
1069         }
1070 
1071         /**
1072          * Messaged to set the user object. This resets the path.
1073          */
1074         public void setUserObject(Object o) {
1075             super.setUserObject(o);
1076             if(path != null) {
1077                 TreeStateNode      parent = (TreeStateNode)getParent();
1078 
1079                 if(parent != null)
1080                     resetChildrenPaths(parent.getTreePath());
1081                 else
1082                     resetChildrenPaths(null);
1083             }
1084         }
1085 
1086         /**
1087          * Returns the children of the receiver.
1088          * If the receiver is not currently expanded, this will return an
1089          * empty enumeration.
1090          */
1091         @Override
1092         public Enumeration<TreeNode> children() {
1093             if (!this.isExpanded()) {
1094                 return DefaultMutableTreeNode.EMPTY_ENUMERATION;
1095             } else {
1096                 return super.children();
1097             }
1098         }
1099 
1100         /**
1101          * Returns true if the receiver is a leaf.
1102          */
1103         public boolean isLeaf() {
1104             return getModel().isLeaf(this.getValue());
1105         }
1106 
1107         //
1108         // VariableHeightLayoutCache
1109         //
1110 
1111         /**
1112          * Returns the location and size of this node.
1113          */
1114         public Rectangle getNodeBounds(Rectangle placeIn) {
1115             if(placeIn == null)
1116                 placeIn = new Rectangle(getXOrigin(), getYOrigin(),
1117                                         getPreferredWidth(),
1118                                         getPreferredHeight());
1119             else {
1120                 placeIn.x = getXOrigin();
1121                 placeIn.y = getYOrigin();
1122                 placeIn.width = getPreferredWidth();
1123                 placeIn.height = getPreferredHeight();
1124             }
1125             return placeIn;
1126         }
1127 
1128         /**
1129          * @return x location to draw node at.
1130          */
1131         public int getXOrigin() {
1132             if(!hasValidSize())
1133                 updatePreferredSize(getRow());
1134             return xOrigin;
1135         }
1136 
1137         /**
1138          * Returns the y origin the user object will be drawn at.
1139          */
1140         public int getYOrigin() {
1141             if(isFixedRowHeight()) {
1142                 int      aRow = getRow();
1143 
1144                 if(aRow == -1)
1145                     return -1;
1146                 return getRowHeight() * aRow;
1147             }
1148             return yOrigin;
1149         }
1150 
1151         /**
1152          * Returns the preferred height of the receiver.
1153          */
1154         public int getPreferredHeight() {
1155             if(isFixedRowHeight())
1156                 return getRowHeight();
1157             else if(!hasValidSize())
1158                 updatePreferredSize(getRow());
1159             return preferredHeight;
1160         }
1161 
1162         /**
1163          * Returns the preferred width of the receiver.
1164          */
1165         public int getPreferredWidth() {
1166             if(!hasValidSize())
1167                 updatePreferredSize(getRow());
1168             return preferredWidth;
1169         }
1170 
1171         /**
1172          * Returns true if this node has a valid size.
1173          */
1174         public boolean hasValidSize() {
1175             return (preferredHeight != 0);
1176         }
1177 
1178         /**
1179          * Returns the row of the receiver.
1180          */
1181         public int getRow() {
1182             return visibleNodes.indexOf(this);
1183         }
1184 
1185         /**
1186          * Returns true if this node has been expanded at least once.
1187          */
1188         public boolean hasBeenExpanded() {
1189             return hasBeenExpanded;
1190         }
1191 
1192         /**
1193          * Returns true if the receiver has been expanded.
1194          */
1195         public boolean isExpanded() {
1196             return expanded;
1197         }
1198 
1199         /**
1200          * Returns the last visible node that is a child of this
1201          * instance.
1202          */
1203         public TreeStateNode getLastVisibleNode() {
1204             TreeStateNode                node = this;
1205 
1206             while(node.isExpanded() && node.getChildCount() > 0)
1207                 node = (TreeStateNode)node.getLastChild();
1208             return node;
1209         }
1210 
1211         /**
1212          * Returns true if the receiver is currently visible.
1213          */
1214         public boolean isVisible() {
1215             if(this == root)
1216                 return true;
1217 
1218             TreeStateNode        parent = (TreeStateNode)getParent();
1219 
1220             return (parent != null && parent.isExpanded() &&
1221                     parent.isVisible());
1222         }
1223 
1224         /**
1225          * Returns the number of children this will have. If the children
1226          * have not yet been loaded, this messages the model.
1227          */
1228         public int getModelChildCount() {
1229             if(hasBeenExpanded)
1230                 return super.getChildCount();
1231             return getModel().getChildCount(getValue());
1232         }
1233 
1234         /**
1235          * Returns the number of visible children, that is the number of
1236          * children that are expanded, or leafs.
1237          */
1238         public int getVisibleChildCount() {
1239             int               childCount = 0;
1240 
1241             if(isExpanded()) {
1242                 int         maxCounter = getChildCount();
1243 
1244                 childCount += maxCounter;
1245                 for(int counter = 0; counter < maxCounter; counter++)
1246                     childCount += ((TreeStateNode)getChildAt(counter)).
1247                                     getVisibleChildCount();
1248             }
1249             return childCount;
1250         }
1251 
1252         /**
1253          * Toggles the receiver between expanded and collapsed.
1254          */
1255         public void toggleExpanded() {
1256             if (isExpanded()) {
1257                 collapse();
1258             } else {
1259                 expand();
1260             }
1261         }
1262 
1263         /**
1264          * Makes the receiver visible, but invoking
1265          * <code>expandParentAndReceiver</code> on the superclass.
1266          */
1267         public void makeVisible() {
1268             TreeStateNode       parent = (TreeStateNode)getParent();
1269 
1270             if(parent != null)
1271                 parent.expandParentAndReceiver();
1272         }
1273 
1274         /**
1275          * Expands the receiver.
1276          */
1277         public void expand() {
1278             expand(true);
1279         }
1280 
1281         /**
1282          * Collapses the receiver.
1283          */
1284         public void collapse() {
1285             collapse(true);
1286         }
1287 
1288         /**
1289          * Returns the value the receiver is representing. This is a cover
1290          * for getUserObject.
1291          */
1292         public Object getValue() {
1293             return getUserObject();
1294         }
1295 
1296         /**
1297          * Returns a TreePath instance for this node.
1298          */
1299         public TreePath getTreePath() {
1300             return path;
1301         }
1302 
1303         //
1304         // Local methods
1305         //
1306 
1307         /**
1308          * Recreates the receivers path, and all its children's paths.
1309          */
1310         protected void resetChildrenPaths(TreePath parentPath) {
1311             removeMapping(this);
1312             if(parentPath == null)
1313                 path = new TreePath(getUserObject());
1314             else
1315                 path = parentPath.pathByAddingChild(getUserObject());
1316             addMapping(this);
1317             for(int counter = getChildCount() - 1; counter >= 0; counter--)
1318                 ((TreeStateNode)getChildAt(counter)).resetChildrenPaths(path);
1319         }
1320 
1321         /**
1322          * Sets y origin the user object will be drawn at to
1323          * <I>newYOrigin</I>.
1324          */
1325         protected void setYOrigin(int newYOrigin) {
1326             yOrigin = newYOrigin;
1327         }
1328 
1329         /**
1330          * Shifts the y origin by <code>offset</code>.
1331          */
1332         protected void shiftYOriginBy(int offset) {
1333             yOrigin += offset;
1334         }
1335 
1336         /**
1337          * Updates the receivers preferredSize by invoking
1338          * <code>updatePreferredSize</code> with an argument of -1.
1339          */
1340         protected void updatePreferredSize() {
1341             updatePreferredSize(getRow());
1342         }
1343 
1344         /**
1345          * Updates the preferred size by asking the current renderer
1346          * for the Dimension needed to draw the user object this
1347          * instance represents.
1348          */
1349         protected void updatePreferredSize(int index) {
1350             Rectangle       bounds = getNodeDimensions(this.getUserObject(),
1351                                                        index, getLevel(),
1352                                                        isExpanded(),
1353                                                        boundsBuffer);
1354 
1355             if(bounds == null || bounds.height == 0) {
1356                 xOrigin = 0;
1357                 preferredWidth = preferredHeight = 0;
1358                 updateNodeSizes = true;
1359             } else {
1360                 xOrigin = bounds.x;
1361                 preferredWidth = bounds.width;
1362                 if(isFixedRowHeight())
1363                     preferredHeight = getRowHeight();
1364                 else
1365                     preferredHeight = bounds.height;
1366             }
1367         }
1368 
1369         /**
1370          * Marks the receivers size as invalid. Next time the size, location
1371          * is asked for it will be obtained.
1372          */
1373         protected void markSizeInvalid() {
1374             preferredHeight = 0;
1375         }
1376 
1377         /**
1378          * Marks the receivers size, and all its descendants sizes, as invalid.
1379          */
1380         protected void deepMarkSizeInvalid() {
1381             markSizeInvalid();
1382             for(int counter = getChildCount() - 1; counter >= 0; counter--)
1383                 ((TreeStateNode)getChildAt(counter)).deepMarkSizeInvalid();
1384         }
1385 
1386         /**
1387          * Returns the children of the receiver. If the children haven't
1388          * been loaded from the model and
1389          * <code>createIfNeeded</code> is true, the children are first
1390          * loaded.
1391          */
1392         protected Enumeration<TreeNode> getLoadedChildren(boolean createIfNeeded) {
1393             if(!createIfNeeded || hasBeenExpanded)
1394                 return super.children();
1395 
1396             TreeStateNode   newNode;
1397             Object          realNode = getValue();
1398             TreeModel       treeModel = getModel();
1399             int             count = treeModel.getChildCount(realNode);
1400 
1401             hasBeenExpanded = true;
1402 
1403             int    childRow = getRow();
1404 
1405             if(childRow == -1) {
1406                 for (int i = 0; i < count; i++) {
1407                     newNode = createNodeForValue
1408                         (treeModel.getChild(realNode, i));
1409                     this.add(newNode);
1410                     newNode.updatePreferredSize(-1);
1411                 }
1412             }
1413             else {
1414                 childRow++;
1415                 for (int i = 0; i < count; i++) {
1416                     newNode = createNodeForValue
1417                         (treeModel.getChild(realNode, i));
1418                     this.add(newNode);
1419                     newNode.updatePreferredSize(childRow++);
1420                 }
1421             }
1422             return super.children();
1423         }
1424 
1425         /**
1426          * Messaged from expand and collapse. This is meant for subclassers
1427          * that may wish to do something interesting with this.
1428          */
1429         protected void didAdjustTree() {
1430         }
1431 
1432         /**
1433          * Invokes <code>expandParentAndReceiver</code> on the parent,
1434          * and expands the receiver.
1435          */
1436         protected void expandParentAndReceiver() {
1437             TreeStateNode       parent = (TreeStateNode)getParent();
1438 
1439             if(parent != null)
1440                 parent.expandParentAndReceiver();
1441             expand();
1442         }
1443 
1444         /**
1445          * Expands this node in the tree.  This will load the children
1446          * from the treeModel if this node has not previously been
1447          * expanded.  If <I>adjustTree</I> is true the tree and selection
1448          * are updated accordingly.
1449          */
1450         protected void expand(boolean adjustTree) {
1451             if (!isExpanded() && !isLeaf()) {
1452                 boolean         isFixed = isFixedRowHeight();
1453                 int             startHeight = getPreferredHeight();
1454                 int             originalRow = getRow();
1455 
1456                 expanded = true;
1457                 updatePreferredSize(originalRow);
1458 
1459                 if (!hasBeenExpanded) {
1460                     TreeStateNode  newNode;
1461                     Object         realNode = getValue();
1462                     TreeModel      treeModel = getModel();
1463                     int            count = treeModel.getChildCount(realNode);
1464                     int offset = originalRow == -1 ? -1 : originalRow + 1;
1465                     hasBeenExpanded = true;
1466 
1467                     for (int i = 0; i < count; i++) {
1468                         newNode = createNodeForValue(treeModel.getChild
1469                                                         (realNode, i));
1470                         this.add(newNode);
1471                         newNode.updatePreferredSize(offset);
1472                     }
1473                 }
1474 
1475                 int i = originalRow;
1476                 Enumeration<TreeNode> cursor = preorderEnumeration();
1477                 cursor.nextElement(); // don't add me, I'm already in
1478 
1479                 int newYOrigin = isFixed || (this == root && !isRootVisible()) ?
1480                                     0 : getYOrigin() + this.getPreferredHeight();
1481 
1482                 TreeStateNode   aNode;
1483                 if(!isFixed) {
1484                     while (cursor.hasMoreElements()) {
1485                         aNode = (TreeStateNode) cursor.nextElement();
1486                         if(!updateNodeSizes && !aNode.hasValidSize())
1487                             aNode.updatePreferredSize(i + 1);
1488                         aNode.setYOrigin(newYOrigin);
1489                         newYOrigin += aNode.getPreferredHeight();
1490                         visibleNodes.insertElementAt(aNode, ++i);
1491                     }
1492                 }
1493                 else {
1494                     while (cursor.hasMoreElements()) {
1495                         aNode = (TreeStateNode) cursor.nextElement();
1496                         visibleNodes.insertElementAt(aNode, ++i);
1497                     }
1498                 }
1499 
1500                 if(adjustTree && (originalRow != i ||
1501                                   getPreferredHeight() != startHeight)) {
1502                     // Adjust the Y origin of any nodes following this row.
1503                     if(!isFixed && ++i < getRowCount()) {
1504                         int              counter;
1505                         int              heightDiff = newYOrigin -
1506                             (getYOrigin() + getPreferredHeight()) +
1507                             (getPreferredHeight() - startHeight);
1508 
1509                         for(counter = visibleNodes.size() - 1;counter >= i;
1510                             counter--)
1511                             ((TreeStateNode)visibleNodes.elementAt(counter)).
1512                                 shiftYOriginBy(heightDiff);
1513                     }
1514                     didAdjustTree();
1515                     visibleNodesChanged();
1516                 }
1517 
1518                 // Update the rows in the selection
1519                 if(treeSelectionModel != null) {
1520                     treeSelectionModel.resetRowSelection();
1521                 }
1522             }
1523         }
1524 
1525         /**
1526          * Collapses this node in the tree.  If <I>adjustTree</I> is
1527          * true the tree and selection are updated accordingly.
1528          */
1529         protected void collapse(boolean adjustTree) {
1530             if (isExpanded()) {
1531                 Enumeration<TreeNode> cursor = preorderEnumeration();
1532                 cursor.nextElement(); // don't remove me, I'm still visible
1533                 int rowsDeleted = 0;
1534                 boolean isFixed = isFixedRowHeight();
1535                 int lastYEnd;
1536                 if(isFixed)
1537                     lastYEnd = 0;
1538                 else
1539                     lastYEnd = getPreferredHeight() + getYOrigin();
1540                 int startHeight = getPreferredHeight();
1541                 int startYEnd = lastYEnd;
1542                 int myRow = getRow();
1543 
1544                 if(!isFixed) {
1545                     while(cursor.hasMoreElements()) {
1546                         TreeStateNode node = (TreeStateNode)cursor.
1547                             nextElement();
1548                         if (node.isVisible()) {
1549                             rowsDeleted++;
1550                             //visibleNodes.removeElement(node);
1551                             lastYEnd = node.getYOrigin() +
1552                                 node.getPreferredHeight();
1553                         }
1554                     }
1555                 }
1556                 else {
1557                     while(cursor.hasMoreElements()) {
1558                         TreeStateNode node = (TreeStateNode)cursor.
1559                             nextElement();
1560                         if (node.isVisible()) {
1561                             rowsDeleted++;
1562                             //visibleNodes.removeElement(node);
1563                         }
1564                     }
1565                 }
1566 
1567                 // Clean up the visible nodes.
1568                 for (int counter = rowsDeleted + myRow; counter > myRow;
1569                      counter--) {
1570                     visibleNodes.removeElementAt(counter);
1571                 }
1572 
1573                 expanded = false;
1574 
1575                 if(myRow == -1)
1576                     markSizeInvalid();
1577                 else if (adjustTree)
1578                     updatePreferredSize(myRow);
1579 
1580                 if(myRow != -1 && adjustTree &&
1581                    (rowsDeleted > 0 || startHeight != getPreferredHeight())) {
1582                     // Adjust the Y origin of any rows following this one.
1583                     startYEnd += (getPreferredHeight() - startHeight);
1584                     if(!isFixed && (myRow + 1) < getRowCount() &&
1585                        startYEnd != lastYEnd) {
1586                         int                 counter, maxCounter, shiftAmount;
1587 
1588                         shiftAmount = startYEnd - lastYEnd;
1589                         for(counter = myRow + 1, maxCounter =
1590                                 visibleNodes.size();
1591                             counter < maxCounter;counter++)
1592                             ((TreeStateNode)visibleNodes.elementAt(counter))
1593                                 .shiftYOriginBy(shiftAmount);
1594                     }
1595                     didAdjustTree();
1596                     visibleNodesChanged();
1597                 }
1598                 if(treeSelectionModel != null && rowsDeleted > 0 &&
1599                    myRow != -1) {
1600                     treeSelectionModel.resetRowSelection();
1601                 }
1602             }
1603         }
1604 
1605         /**
1606          * Removes the receiver, and all its children, from the mapping
1607          * table.
1608          */
1609         protected void removeFromMapping() {
1610             if(path != null) {
1611                 removeMapping(this);
1612                 for(int counter = getChildCount() - 1; counter >= 0; counter--)
1613                     ((TreeStateNode)getChildAt(counter)).removeFromMapping();
1614             }
1615         }
1616     } // End of VariableHeightLayoutCache.TreeStateNode
1617 
1618 
1619     /**
1620      * An enumerator to iterate through visible nodes.
1621      */
1622     private class VisibleTreeStateNodeEnumeration implements
1623                      Enumeration<TreePath> {
1624         /** Parent thats children are being enumerated. */
1625         protected TreeStateNode       parent;
1626         /** Index of next child. An index of -1 signifies parent should be
1627          * visibled next. */
1628         protected int                 nextIndex;
1629         /** Number of children in parent. */
1630         protected int                 childCount;
1631 
1632         protected VisibleTreeStateNodeEnumeration(TreeStateNode node) {
1633             this(node, -1);
1634         }
1635 
1636         protected VisibleTreeStateNodeEnumeration(TreeStateNode parent,
1637                                                   int startIndex) {
1638             this.parent = parent;
1639             this.nextIndex = startIndex;
1640             this.childCount = this.parent.getChildCount();
1641         }
1642 
1643         /**
1644          * @return true if more visible nodes.
1645          */
1646         public boolean hasMoreElements() {
1647             return (parent != null);
1648         }
1649 
1650         /**
1651          * @return next visible TreePath.
1652          */
1653         public TreePath nextElement() {
1654             if(!hasMoreElements())
1655                 throw new NoSuchElementException("No more visible paths");
1656 
1657             TreePath                retObject;
1658 
1659             if(nextIndex == -1) {
1660                 retObject = parent.getTreePath();
1661             }
1662             else {
1663                 TreeStateNode   node = (TreeStateNode)parent.
1664                                         getChildAt(nextIndex);
1665 
1666                 retObject = node.getTreePath();
1667             }
1668             updateNextObject();
1669             return retObject;
1670         }
1671 
1672         /**
1673          * Determines the next object by invoking <code>updateNextIndex</code>
1674          * and if not succesful <code>findNextValidParent</code>.
1675          */
1676         protected void updateNextObject() {
1677             if(!updateNextIndex()) {
1678                 findNextValidParent();
1679             }
1680         }
1681 
1682         /**
1683          * Finds the next valid parent, this should be called when nextIndex
1684          * is beyond the number of children of the current parent.
1685          */
1686         protected boolean findNextValidParent() {
1687             if(parent == root) {
1688                 // mark as invalid!
1689                 parent = null;
1690                 return false;
1691             }
1692             while(parent != null) {
1693                 TreeStateNode      newParent = (TreeStateNode)parent.
1694                                                   getParent();
1695 
1696                 if(newParent != null) {
1697                     nextIndex = newParent.getIndex(parent);
1698                     parent = newParent;
1699                     childCount = parent.getChildCount();
1700                     if(updateNextIndex())
1701                         return true;
1702                 }
1703                 else
1704                     parent = null;
1705             }
1706             return false;
1707         }
1708 
1709         /**
1710          * Updates <code>nextIndex</code> returning false if it is beyond
1711          * the number of children of parent.
1712          */
1713         protected boolean updateNextIndex() {
1714             // nextIndex == -1 identifies receiver, make sure is expanded
1715             // before descend.
1716             if((nextIndex == -1 && !parent.isExpanded()) ||
1717                 childCount == 0 || // Check that it can have kids
1718                 nextIndex + 1 >= childCount) // Make sure next index not beyond
1719                                              // child count.
1720                 return false;
1721 
1722             ++nextIndex;
1723             TreeStateNode       child = (TreeStateNode)parent.
1724                                         getChildAt(nextIndex);
1725 
1726             if(child != null && child.isExpanded()) {
1727                 parent = child;
1728                 nextIndex = -1;
1729                 childCount = child.getChildCount();
1730             }
1731             return true;
1732         }
1733     } // VariableHeightLayoutCache.VisibleTreeStateNodeEnumeration
1734 }