home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 March / pcp161a.iso / handson / files / copyjava.exe / com / sun / java / swing / plaf / basic / AbstractTreeUI.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-02-26  |  21.1 KB  |  1,348 lines
  1. package com.sun.java.swing.plaf.basic;
  2.  
  3. import com.sun.java.swing.event.TreeModelEvent;
  4. import com.sun.java.swing.event.TreeModelListener;
  5. import com.sun.java.swing.event.TreeSelectionEvent;
  6. import com.sun.java.swing.event.TreeSelectionListener;
  7. import com.sun.java.swing.plaf.TreeUI;
  8. import com.sun.java.swing.tree.DefaultMutableTreeNode;
  9. import com.sun.java.swing.tree.RowMapper;
  10. import com.sun.java.swing.tree.TreeModel;
  11. import com.sun.java.swing.tree.TreeNode;
  12. import com.sun.java.swing.tree.TreePath;
  13. import com.sun.java.swing.tree.TreeSelectionModel;
  14. import java.awt.Dimension;
  15. import java.awt.Rectangle;
  16. import java.io.IOException;
  17. import java.io.ObjectInputStream;
  18. import java.io.ObjectOutputStream;
  19. import java.io.Serializable;
  20. import java.util.Enumeration;
  21. import java.util.Vector;
  22.  
  23. public abstract class AbstractTreeUI extends TreeUI implements Serializable, TreeModelListener, RowMapper, TreeSelectionListener {
  24.    protected transient TreeModel treeModel;
  25.    protected boolean rootVisible;
  26.    protected VisibleTreeNode treeCacheRoot;
  27.    protected Vector visibleNodes = new Vector();
  28.    protected boolean updateNodeSizes;
  29.    protected int rowHeight = 16;
  30.    protected boolean showsRootHandles;
  31.    protected TreeSelectionModel treeSelectionModel;
  32.    protected LargeTreeModelNode largeRoot;
  33.    protected boolean largeModel;
  34.    protected int largeRowCount;
  35.  
  36.    public void setModel(TreeModel var1) {
  37.       TreeModel var2 = this.treeModel;
  38.       if (var1 != var2) {
  39.          if (var2 != null) {
  40.             var2.removeTreeModelListener(this);
  41.          }
  42.  
  43.          this.treeModel = var1;
  44.          if (this.treeModel != null) {
  45.             this.treeModel.addTreeModelListener(this);
  46.          }
  47.  
  48.          this.rebuild();
  49.       }
  50.  
  51.    }
  52.  
  53.    public TreeModel getModel() {
  54.       return this.treeModel;
  55.    }
  56.  
  57.    public void setLargeModel(boolean var1) {
  58.       if (this.largeModel != var1) {
  59.          this.largeModel = var1;
  60.          if (var1 && this.rowHeight <= 0) {
  61.             this.rowHeight = 16;
  62.          }
  63.  
  64.          this.rebuild();
  65.       }
  66.  
  67.    }
  68.  
  69.    public boolean isLargeModel() {
  70.       return this.largeModel;
  71.    }
  72.  
  73.    public void setRootVisible(boolean var1) {
  74.       if (var1 != this.rootVisible) {
  75.          this.rootVisible = var1;
  76.          if (this.treeModel != null) {
  77.             if (!this.largeModel) {
  78.                if (this.rootVisible) {
  79.                   this.treeCacheRoot.updatePreferredSize(0);
  80.                   this.visibleNodes.insertElementAt(this.treeCacheRoot, 0);
  81.                } else if (this.visibleNodes.size() > 0) {
  82.                   this.visibleNodes.removeElementAt(0);
  83.                   if (this.treeSelectionModel != null) {
  84.                      this.treeSelectionModel.removeSelectionPath(this.treeCacheRoot.getTreePath());
  85.                   }
  86.                }
  87.  
  88.                if (this.treeSelectionModel != null) {
  89.                   this.treeSelectionModel.resetRowSelection();
  90.                }
  91.  
  92.                if (this.getRowCount() > 0) {
  93.                   this.getNode(0).setYOrigin(0);
  94.                }
  95.  
  96.                this.updateYLocationsFrom(0);
  97.                this.visibleNodesChanged();
  98.                return;
  99.             }
  100.  
  101.             if (this.rootVisible) {
  102.                ++this.largeRowCount;
  103.             } else {
  104.                --this.largeRowCount;
  105.             }
  106.  
  107.             if (this.treeSelectionModel != null) {
  108.                this.treeSelectionModel.clearSelection();
  109.             }
  110.  
  111.             this.visibleNodesChanged();
  112.          }
  113.       }
  114.  
  115.    }
  116.  
  117.    public boolean isRootVisible() {
  118.       return this.rootVisible;
  119.    }
  120.  
  121.    public void setShowsRootHandles(boolean var1) {
  122.       if (this.showsRootHandles != var1) {
  123.          this.showsRootHandles = var1;
  124.          this.visibleNodesChanged();
  125.       }
  126.  
  127.    }
  128.  
  129.    public boolean getShowsRootHandles() {
  130.       return this.showsRootHandles;
  131.    }
  132.  
  133.    public void setRowHeight(int var1) {
  134.       if (var1 != this.rowHeight) {
  135.          if (!this.largeModel) {
  136.             this.rowHeight = var1;
  137.             if (!this.isFixedRowHeight() && this.visibleNodes.size() > 0) {
  138.                this.updateNodeSizes(true);
  139.             } else if (this.isFixedRowHeight()) {
  140.                for(int var2 = this.getRowCount() - 1; var2 >= 0; --var2) {
  141.                   this.getNode(var2).getPreferredSize().height = var1;
  142.                }
  143.             }
  144.  
  145.             this.visibleNodesChanged();
  146.             return;
  147.          }
  148.  
  149.          if (var1 <= 0) {
  150.             throw new IllegalArgumentException("AbstractTreeUI.setRowHeight() row height must be > 0 for large models");
  151.          }
  152.  
  153.          this.rowHeight = var1;
  154.          this.visibleNodesChanged();
  155.       }
  156.  
  157.    }
  158.  
  159.    public int getRowHeight() {
  160.       return this.rowHeight;
  161.    }
  162.  
  163.    public boolean isFixedRowHeight() {
  164.       return this.rowHeight > 0;
  165.    }
  166.  
  167.    public abstract int getXOriginOfNode(VisibleTreeNode var1);
  168.  
  169.    public abstract Dimension getSizeOfNode(VisibleTreeNode var1, int var2);
  170.  
  171.    protected abstract Rectangle getLargeBoundsOf(LargeTreeModelNode var1, int var2, Object var3);
  172.  
  173.    public abstract void visibleNodesChanged();
  174.  
  175.    protected abstract void pathWasExpanded(TreePath var1);
  176.  
  177.    protected abstract void pathWasCollapsed(TreePath var1);
  178.  
  179.    protected boolean isAbstractTreePath(TreePath var1, boolean var2, boolean var3) {
  180.       if (var1 != null && var1 instanceof AbstractTreePath) {
  181.          AbstractTreePath var4 = (AbstractTreePath)var1;
  182.          if (var4.node == null || var4.getUI() == this) {
  183.             if (var4.node == null || !var4.node.isValid) {
  184.                var4.node = this.getNodeForPath(var1.getPath(), false, var3);
  185.                if (var4.node == null) {
  186.                   return false;
  187.                }
  188.             }
  189.  
  190.             return true;
  191.          }
  192.       }
  193.  
  194.       return false;
  195.    }
  196.  
  197.    protected VisibleTreeNode getNodeForTreePath(TreePath var1, boolean var2, boolean var3) {
  198.       if (this.isAbstractTreePath(var1, var2, var3)) {
  199.          VisibleTreeNode var4 = ((AbstractTreePath)var1).node;
  200.          if (var4 == null) {
  201.             return null;
  202.          } else {
  203.             return var2 && !var4.isVisible() ? null : var4;
  204.          }
  205.       } else {
  206.          return var1 != null ? this.getNodeForPath(var1.getPath(), var2, var3) : null;
  207.       }
  208.    }
  209.  
  210.    protected VisibleTreeNode[] getNodesForTreePath(TreePath var1, boolean var2, boolean var3) {
  211.       if (this.isAbstractTreePath(var1, var2, var3)) {
  212.          VisibleTreeNode var4 = ((AbstractTreePath)var1).node;
  213.          if (var4 == null) {
  214.             return null;
  215.          } else if (var2 && !var4.isVisible()) {
  216.             return null;
  217.          } else {
  218.             TreeNode[] var5 = ((DefaultMutableTreeNode)var4).getPath();
  219.             VisibleTreeNode[] var6 = new VisibleTreeNode[var5.length];
  220.             System.arraycopy(var5, 0, var6, 0, var5.length);
  221.             return var6;
  222.          }
  223.       } else {
  224.          return var1 != null ? this.getNodesForPath(var1.getPath(), var2, var3) : null;
  225.       }
  226.    }
  227.  
  228.    protected TreePath ensurePathIsAbstract(TreePath var1, VisibleTreeNode var2) {
  229.       return (TreePath)(var1 != null && !(var1 instanceof AbstractTreePath) ? new AbstractTreePath(var1.getPath(), var2) : var1);
  230.    }
  231.  
  232.    public VisibleTreeNode getNodeForPath(Object[] var1, boolean var2, boolean var3) {
  233.       VisibleTreeNode[] var4 = this.getNodesForPath(var1, var2, var3);
  234.       return var4 != null && var4.length > 0 ? var4[var4.length - 1] : null;
  235.    }
  236.  
  237.    public VisibleTreeNode[] getNodesForPath(Object[] var1, boolean var2, boolean var3) {
  238.       if (var1 != null && var1.length > 0 && this.treeModel != null) {
  239.          if (!this.treeCacheRoot.getValue().equals(var1[0])) {
  240.             return null;
  241.          } else {
  242.             VisibleTreeNode var5 = this.treeCacheRoot;
  243.             int var4 = 1;
  244.             if (var2 && var1.length > 1 && !var5.isExpanded()) {
  245.                return null;
  246.             } else {
  247.                VisibleTreeNode[] var6 = new VisibleTreeNode[var1.length];
  248.                var6[0] = var5;
  249.  
  250.                while(var5 != null && var4 < var1.length) {
  251.                   VisibleTreeNode var8 = null;
  252.                   Enumeration var7 = var5.getLoadedChildren(var3);
  253.  
  254.                   while(var7.hasMoreElements() && var8 == null) {
  255.                      var8 = (VisibleTreeNode)var7.nextElement();
  256.                      if (!var8.getValue().equals(var1[var4])) {
  257.                         var8 = null;
  258.                      }
  259.                   }
  260.  
  261.                   var5 = var8;
  262.                   var6[var4] = var8;
  263.                   ++var4;
  264.                   if (var8 != null && var2 && var4 < var1.length && !var8.isExpanded()) {
  265.                      var5 = null;
  266.                   }
  267.                }
  268.  
  269.                return var5 != null ? var6 : null;
  270.             }
  271.          }
  272.       } else {
  273.          return null;
  274.       }
  275.    }
  276.  
  277.    protected void updateYLocationsFrom(int var1) {
  278.       if (var1 >= 0 && var1 < this.getRowCount()) {
  279.          VisibleTreeNode var5 = this.getNode(var1);
  280.          int var4 = var5.getYOrigin() + var5.getPreferredSize().height;
  281.          int var2 = var1 + 1;
  282.  
  283.          for(int var3 = this.visibleNodes.size(); var2 < var3; ++var2) {
  284.             var5 = (VisibleTreeNode)this.visibleNodes.elementAt(var2);
  285.             var5.setYOrigin(var4);
  286.             var4 += var5.getPreferredSize().height;
  287.          }
  288.       }
  289.  
  290.    }
  291.  
  292.    public synchronized void treeNodesChanged(TreeModelEvent var1) {
  293.       if (var1 != null) {
  294.          if (this.largeModel) {
  295.             this.visibleNodesChanged();
  296.             return;
  297.          }
  298.  
  299.          int[] var2 = var1.getChildIndices();
  300.          VisibleTreeNode var3 = this.getNodeForPath(var1.getPath(), false, false);
  301.          if (var3 != null) {
  302.             Object var4 = var3.getValue();
  303.             var3.updatePreferredSize();
  304.             if (var2 != null) {
  305.                for(int var5 = 0; var5 < var2.length; ++var5) {
  306.                   try {
  307.                      VisibleTreeNode var6 = (VisibleTreeNode)((DefaultMutableTreeNode)var3).getChildAt(var2[var5]);
  308.                      ((DefaultMutableTreeNode)var6).setUserObject(this.treeModel.getChild(var4, var2[var5]));
  309.                      var6.updatePreferredSize();
  310.                   } catch (Exception var7) {
  311.                   }
  312.                }
  313.             }
  314.  
  315.             if (!this.isFixedRowHeight()) {
  316.                int var8 = var3.getRow();
  317.                if (var8 != -1) {
  318.                   this.updateYLocationsFrom(var8);
  319.                }
  320.             }
  321.  
  322.             this.visibleNodesChanged();
  323.          }
  324.       }
  325.  
  326.    }
  327.  
  328.    protected VisibleTreeNode createNodeAt(VisibleTreeNode var1, int var2) {
  329.       VisibleTreeNode var5;
  330.       try {
  331.          Object var4 = this.treeModel.getChild(var1.getValue(), var2);
  332.          var5 = this.createNodeForValue(var4, -1);
  333.          ((DefaultMutableTreeNode)var1).insert(var5, var2);
  334.       } catch (Exception var8) {
  335.          var5 = null;
  336.       }
  337.  
  338.       boolean var3 = var1 == this.treeCacheRoot;
  339.       if (var5 != null && var1.isExpanded() && (var1.getRow() != -1 || var3)) {
  340.          int var6;
  341.          if (var2 == 0) {
  342.             if (var3 && !this.isRootVisible()) {
  343.                var6 = 0;
  344.             } else {
  345.                var6 = var1.getRow() + 1;
  346.             }
  347.          } else if (var2 == ((DefaultMutableTreeNode)var1).getChildCount()) {
  348.             var6 = var1.getLastVisibleNode().getRow() + 1;
  349.          } else {
  350.             VisibleTreeNode var7 = (VisibleTreeNode)((DefaultMutableTreeNode)var1).getChildAt(var2 - 1);
  351.             var6 = var7.getLastVisibleNode().getRow() + 1;
  352.          }
  353.  
  354.          this.visibleNodes.insertElementAt(var5, var6);
  355.       }
  356.  
  357.       return var5;
  358.    }
  359.  
  360.    public synchronized void treeNodesInserted(TreeModelEvent var1) {
  361.       if (var1 != null && !this.largeModel) {
  362.          int[] var8 = var1.getChildIndices();
  363.          VisibleTreeNode var9 = this.getNodeForPath(var1.getPath(), false, false);
  364.          if (var9 != null && var8 != null && var8.length > 0) {
  365.             if (var9.hasBeenExpanded()) {
  366.                Object var12 = var9.getValue();
  367.                boolean var10 = var9 == this.treeCacheRoot && !this.rootVisible || var9.getRow() != -1 && var9.isExpanded();
  368.  
  369.                for(int var11 = 0; var11 < var8.length; ++var11) {
  370.                   this.createNodeAt(var9, var8[var11]);
  371.                }
  372.  
  373.                if (this.treeSelectionModel != null) {
  374.                   this.treeSelectionModel.resetRowSelection();
  375.                }
  376.  
  377.                if (!this.isFixedRowHeight() && var10) {
  378.                   if (var9 == this.treeCacheRoot) {
  379.                      this.updateYLocationsFrom(0);
  380.                   } else {
  381.                      this.updateYLocationsFrom(var9.getRow());
  382.                   }
  383.  
  384.                   this.visibleNodesChanged();
  385.                   return;
  386.                }
  387.  
  388.                if (var10) {
  389.                   this.visibleNodesChanged();
  390.                   return;
  391.                }
  392.             } else {
  393.                var9.modelChildCountChanged();
  394.             }
  395.  
  396.             return;
  397.          }
  398.       } else if (var1 != null) {
  399.          LargeTreeModelNode var3 = this.getLargeTreeModelNodeForPath(var1.getPath(), false, false);
  400.          int[] var2 = var1.getChildIndices();
  401.          int var4;
  402.          if (var3 != null && var2 != null && (var4 = var2.length) > 0) {
  403.             boolean var5 = var3.isVisible() && var3.isExpanded();
  404.  
  405.             for(int var6 = 0; var6 < var4; ++var6) {
  406.                var3.childInsertedAtModelIndex(var2[var6]);
  407.                if (var5) {
  408.                   ++this.largeRowCount;
  409.                }
  410.             }
  411.  
  412.             if (var5 && this.treeSelectionModel != null) {
  413.                this.treeSelectionModel.resetRowSelection();
  414.             }
  415.  
  416.             if (var5) {
  417.                this.visibleNodesChanged();
  418.                return;
  419.             }
  420.  
  421.             var3.modelChildCountChanged();
  422.          }
  423.       }
  424.  
  425.    }
  426.  
  427.    public synchronized void treeNodesRemoved(TreeModelEvent var1) {
  428.       if (var1 != null && !this.largeModel) {
  429.          int[] var13 = var1.getChildIndices();
  430.          VisibleTreeNode var14 = this.getNodeForPath(var1.getPath(), false, false);
  431.          if (var14 != null && var13 != null && var13.length > 0) {
  432.             if (var14.hasBeenExpanded()) {
  433.                boolean var15 = var14 == this.treeCacheRoot && !this.rootVisible || var14.getRow() != -1 && var14.isExpanded();
  434.  
  435.                for(int var16 = var13.length - 1; var16 >= 0; --var16) {
  436.                   try {
  437.                      VisibleTreeNode var18 = (VisibleTreeNode)((DefaultMutableTreeNode)var14).getChildAt(var13[var16]);
  438.                      if (var18.isExpanded()) {
  439.                         var18.collapse(false);
  440.                      }
  441.  
  442.                      if (var15) {
  443.                         int var17 = var18.getRow();
  444.                         if (var17 != -1) {
  445.                            this.visibleNodes.removeElementAt(var17);
  446.                            if (this.treeSelectionModel != null) {
  447.                               TreePath var19 = var18.getTreePath();
  448.                               this.treeSelectionModel.removeSelectionPath(var19);
  449.                            }
  450.                         }
  451.                      }
  452.  
  453.                      ((DefaultMutableTreeNode)var14).remove(var18);
  454.                   } catch (Exception var12) {
  455.                      System.out.println("Exception removing node" + var12);
  456.                   }
  457.                }
  458.  
  459.                if (this.treeSelectionModel != null) {
  460.                   this.treeSelectionModel.resetRowSelection();
  461.                }
  462.  
  463.                if (!this.isFixedRowHeight() && var15) {
  464.                   if (var14 == this.treeCacheRoot) {
  465.                      if (this.getRowCount() > 0) {
  466.                         this.getNode(0).setYOrigin(0);
  467.                      }
  468.  
  469.                      this.updateYLocationsFrom(0);
  470.                   } else {
  471.                      this.updateYLocationsFrom(var14.getRow());
  472.                   }
  473.  
  474.                   this.visibleNodesChanged();
  475.                   return;
  476.                }
  477.  
  478.                if (var15) {
  479.                   this.visibleNodesChanged();
  480.                   return;
  481.                }
  482.             } else {
  483.                var14.modelChildCountChanged();
  484.             }
  485.  
  486.             return;
  487.          }
  488.       } else if (var1 != null) {
  489.          Object[] var4 = var1.getPath();
  490.          LargeTreeModelNode var5 = this.getLargeTreeModelNodeForPath(var4, false, false);
  491.          int[] var2 = var1.getChildIndices();
  492.          int var3;
  493.          if (var5 != null && var2 != null && (var3 = var2.length) > 0) {
  494.             Object[] var7 = var1.getChildren();
  495.             int var8 = var4.length;
  496.             boolean var9 = var5.isVisible() && var5.isExpanded();
  497.  
  498.             for(int var11 = 0; var11 < var3; ++var11) {
  499.                LargeTreeModelNode var10 = var5.childAtModelIndex(var2[var11]);
  500.                if (var10 != null) {
  501.                   var10.collapse(false);
  502.                   ((DefaultMutableTreeNode)var5).remove(var10);
  503.                }
  504.  
  505.                if (var9) {
  506.                   --this.largeRowCount;
  507.                }
  508.  
  509.                var5.childRemovedAtModelIndex(var2[var11]);
  510.                if (this.treeSelectionModel != null && var7 != null && var7[var11] != null) {
  511.                   Object[] var6 = new Object[var8 + 1];
  512.                   System.arraycopy(var4, 0, var6, 0, var8);
  513.                   var6[var8] = var7[var11];
  514.                   this.treeSelectionModel.removeSelectionPath(new TreePath(var6));
  515.                }
  516.             }
  517.  
  518.             if (var9) {
  519.                if (this.treeSelectionModel != null) {
  520.                   this.treeSelectionModel.resetRowSelection();
  521.                }
  522.  
  523.                this.visibleNodesChanged();
  524.                return;
  525.             }
  526.  
  527.             var5.modelChildCountChanged();
  528.          }
  529.       }
  530.  
  531.    }
  532.  
  533.    public synchronized void treeStructureChanged(TreeModelEvent var1) {
  534.       if (var1 != null && !this.largeModel) {
  535.          Object[] var10 = var1.getPath();
  536.          VisibleTreeNode var12 = this.getNodeForPath(var10, false, false);
  537.          if (var12 == null && var10 != null && var10.length == 1) {
  538.             var12 = this.treeCacheRoot;
  539.          }
  540.  
  541.          if (var12 != null) {
  542.             boolean var13 = var12.isExpanded();
  543.             boolean var14 = var12.getRow() != -1;
  544.             if (var12 == this.treeCacheRoot) {
  545.                this.rebuild();
  546.                return;
  547.             }
  548.  
  549.             VisibleTreeNode var9 = (VisibleTreeNode)((DefaultMutableTreeNode)var12).getParent();
  550.             int var7 = ((DefaultMutableTreeNode)var9).getIndex(var12);
  551.             if (var14 && var13) {
  552.                var12.collapse(false);
  553.             }
  554.  
  555.             if (var14) {
  556.                this.visibleNodes.removeElement(var12);
  557.             }
  558.  
  559.             ((DefaultMutableTreeNode)var12).removeFromParent();
  560.             this.createNodeAt(var9, var7);
  561.             VisibleTreeNode var8 = (VisibleTreeNode)((DefaultMutableTreeNode)var9).getChildAt(var7);
  562.             if (var14 && var13) {
  563.                var8.expand(false);
  564.             }
  565.  
  566.             int var15 = var8.getRow();
  567.             if (!this.isFixedRowHeight() && var14) {
  568.                if (var15 == 0) {
  569.                   this.updateYLocationsFrom(var15);
  570.                } else {
  571.                   this.updateYLocationsFrom(var15 - 1);
  572.                }
  573.  
  574.                this.visibleNodesChanged();
  575.                return;
  576.             }
  577.  
  578.             if (var14) {
  579.                this.visibleNodesChanged();
  580.                return;
  581.             }
  582.          }
  583.       } else if (var1 != null) {
  584.          Object[] var2 = var1.getPath();
  585.          if (var2 != null && var2.length > 0) {
  586.             if (var2.length == 1) {
  587.                this.rebuild();
  588.                return;
  589.             }
  590.  
  591.             LargeTreeModelNode var3 = this.getLargeTreeModelNodeForPath(var2, false, false);
  592.             if (var3 != null) {
  593.                LargeTreeModelNode var6 = (LargeTreeModelNode)((DefaultMutableTreeNode)var3).getParent();
  594.                boolean var4 = var3.isExpanded();
  595.                boolean var5 = var3.isVisible();
  596.                if (var5 && var4) {
  597.                   var3.collapse(false);
  598.                   ((DefaultMutableTreeNode)var3).removeFromParent();
  599.                   var3 = this.getLargeTreeModelNodeForPath(var2, false, true);
  600.                   var3.expand(false);
  601.                } else {
  602.                   ((DefaultMutableTreeNode)var3).removeFromParent();
  603.                }
  604.  
  605.                if (this.treeSelectionModel != null && var5 && var4) {
  606.                   this.treeSelectionModel.resetRowSelection();
  607.                }
  608.  
  609.                if (var5) {
  610.                   this.visibleNodesChanged();
  611.                   return;
  612.                }
  613.  
  614.                var6.modelChildCountChanged();
  615.             }
  616.          }
  617.       }
  618.  
  619.    }
  620.  
  621.    public void rebuild() {
  622.       if (!this.largeModel && this.treeCacheRoot != null) {
  623.          this.treeCacheRoot.markInvalid();
  624.       }
  625.  
  626.       if (this.treeModel != null) {
  627.          if (!this.largeModel) {
  628.             this.largeRoot = null;
  629.             this.treeCacheRoot = this.createNodeForValue(this.treeModel.getRoot(), 0);
  630.             this.visibleNodes.removeAllElements();
  631.             if (this.isRootVisible()) {
  632.                this.visibleNodes.addElement(this.treeCacheRoot);
  633.             }
  634.  
  635.             if (!this.treeCacheRoot.isExpanded()) {
  636.                this.treeCacheRoot.expand();
  637.             } else {
  638.                Enumeration var1 = this.treeCacheRoot.children();
  639.  
  640.                while(var1.hasMoreElements()) {
  641.                   this.visibleNodes.addElement(var1.nextElement());
  642.                }
  643.  
  644.                if (!this.isFixedRowHeight()) {
  645.                   this.updateYLocationsFrom(0);
  646.                }
  647.             }
  648.          } else {
  649.             this.treeCacheRoot = null;
  650.             this.visibleNodes.removeAllElements();
  651.             this.largeRoot = this.createLargeTreeModelNodeForValue(this.treeModel.getRoot(), 0);
  652.             if (this.isRootVisible()) {
  653.                this.largeRowCount = 1;
  654.             } else {
  655.                this.largeRowCount = 0;
  656.             }
  657.  
  658.             this.largeRoot.expand(true);
  659.          }
  660.       } else {
  661.          this.visibleNodes.removeAllElements();
  662.          this.treeCacheRoot = null;
  663.          this.largeRoot = null;
  664.          this.largeRowCount = 0;
  665.       }
  666.  
  667.       if (this.treeSelectionModel != null) {
  668.          this.treeSelectionModel.clearSelection();
  669.       }
  670.  
  671.       this.visibleNodesChanged();
  672.    }
  673.  
  674.    public void updateNodeSizes(boolean var1) {
  675.       this.updateNodeSizes = false;
  676.       int var3 = 0;
  677.       int var2 = 0;
  678.  
  679.       for(int var4 = this.visibleNodes.size(); var3 < var4; ++var3) {
  680.          VisibleTreeNode var5 = (VisibleTreeNode)this.visibleNodes.elementAt(var3);
  681.          var5.setYOrigin(var2);
  682.          if (var1 || !var5.hasValidSize()) {
  683.             var5.updatePreferredSize(var3);
  684.          }
  685.  
  686.          var2 += var5.getPreferredSize().height;
  687.       }
  688.  
  689.    }
  690.  
  691.    public int getYOriginOfRow(int var1) {
  692.       if (var1 < 0) {
  693.          return -1;
  694.       } else if (var1 >= this.getRowCount()) {
  695.          return -1;
  696.       } else {
  697.          return this.isFixedRowHeight() ? var1 * this.getRowHeight() : this.getNode(var1).getYOrigin();
  698.       }
  699.    }
  700.  
  701.    public int getRowContainingYLocation(int var1) {
  702.       if (this.isFixedRowHeight()) {
  703.          return this.getRowCount() == 0 ? -1 : Math.max(0, Math.min(this.getRowCount() - 1, var1 / this.getRowHeight()));
  704.       } else {
  705.          int var2;
  706.          if ((var2 = this.getRowCount()) <= 0) {
  707.             return -1;
  708.          } else {
  709.             int var5 = 0;
  710.             int var4 = 0;
  711.  
  712.             while(var5 < var2) {
  713.                var4 = (var2 - var5) / 2 + var5;
  714.                VisibleTreeNode var7 = (VisibleTreeNode)this.visibleNodes.elementAt(var4);
  715.                int var6 = var7.getYOrigin();
  716.                int var3 = var6 + var7.getPreferredSize().height;
  717.                if (var1 < var6) {
  718.                   var2 = var4 - 1;
  719.                } else {
  720.                   if (var1 < var3) {
  721.                      break;
  722.                   }
  723.  
  724.                   var5 = var4 + 1;
  725.                }
  726.             }
  727.  
  728.             if (var5 == var2) {
  729.                var4 = var5;
  730.                if (var5 >= this.getRowCount()) {
  731.                   var4 = this.getRowCount() - 1;
  732.                }
  733.             }
  734.  
  735.             return var4;
  736.          }
  737.       }
  738.    }
  739.  
  740.    protected boolean ensureLargePathIsExpanded(TreePath var1, boolean var2) {
  741.       Object[] var3 = var1.getPath();
  742.       if (var3 != null) {
  743.          int var4 = var3.length;
  744.          if (this.treeModel.isLeaf(var3[var4 - 1])) {
  745.             if (var4 == 1) {
  746.                var3 = null;
  747.             } else {
  748.                Object[] var5 = new Object[var4 - 1];
  749.                System.arraycopy(var3, 0, var5, 0, var4 - 1);
  750.                var3 = var5;
  751.                var2 = true;
  752.             }
  753.          }
  754.  
  755.          if (var3 != null) {
  756.             LargeTreeModelNode var9 = this.getLargeTreeModelNodeForPath(var3, false, true);
  757.             if (var9 != null) {
  758.                TreeNode[] var6 = ((DefaultMutableTreeNode)var9).getPath();
  759.                int var7 = var6.length - 1;
  760.  
  761.                for(int var8 = 0; var8 < var7; ++var8) {
  762.                   ((LargeTreeModelNode)var6[var8]).expand(true);
  763.                }
  764.  
  765.                if (var2) {
  766.                   ((LargeTreeModelNode)var6[var7]).expand(true);
  767.                }
  768.  
  769.                return true;
  770.             }
  771.          }
  772.       }
  773.  
  774.       return false;
  775.    }
  776.  
  777.    protected VisibleTreeNode[] ensurePathIsExpanded(TreePath var1, boolean var2) {
  778.       VisibleTreeNode[] var3 = this.getNodesForTreePath(var1, false, true);
  779.       if (var3 != null) {
  780.          int var4 = 0;
  781.  
  782.          for(int var5 = var2 ? var3.length : var3.length - 1; var4 < var5; ++var4) {
  783.             if (!var3[var4].isExpanded()) {
  784.                var3[var4].expand();
  785.             }
  786.          }
  787.       }
  788.  
  789.       return var3;
  790.    }
  791.  
  792.    public TreePath getSelectionPath() {
  793.       return this.treeSelectionModel != null ? this.treeSelectionModel.getSelectionPath() : null;
  794.    }
  795.  
  796.    public TreePath[] getSelectionPaths() {
  797.       return this.treeSelectionModel != null ? this.treeSelectionModel.getSelectionPaths() : null;
  798.    }
  799.  
  800.    public int[] getSelectionRows() {
  801.       return this.treeSelectionModel != null ? this.treeSelectionModel.getSelectionRows() : null;
  802.    }
  803.  
  804.    public int getMinSelectionRow() {
  805.       return this.treeSelectionModel != null ? this.treeSelectionModel.getMinSelectionRow() : -1;
  806.    }
  807.  
  808.    public int getMaxSelectionRow() {
  809.       return this.treeSelectionModel != null ? this.treeSelectionModel.getMaxSelectionRow() : -1;
  810.    }
  811.  
  812.    public boolean isPathSelected(TreePath var1) {
  813.       return this.treeSelectionModel != null ? this.treeSelectionModel.isPathSelected(var1) : false;
  814.    }
  815.  
  816.    public boolean isRowSelected(int var1) {
  817.       return this.treeSelectionModel != null ? this.treeSelectionModel.isRowSelected(var1) : false;
  818.    }
  819.  
  820.    public boolean isExpanded(TreePath var1) {
  821.       if (!this.largeModel) {
  822.          VisibleTreeNode var2 = this.getNodeForTreePath(var1, true, false);
  823.          if (var2 != null) {
  824.             return var2.isExpanded();
  825.          }
  826.       } else if (var1 != null) {
  827.          LargeTreeModelNode var3 = this.getLargeTreeModelNodeForPath(var1.getPath(), true, false);
  828.          if (var3 != null && var3.isExpanded()) {
  829.             return true;
  830.          }
  831.  
  832.          return false;
  833.       }
  834.  
  835.       return false;
  836.    }
  837.  
  838.    public boolean isExpanded(int var1) {
  839.       if (!this.largeModel) {
  840.          return this.getNode(var1).isExpanded();
  841.       } else {
  842.          LargeTreeModelNode var2 = this.getLargeTreeModelNodeForRow(var1, false);
  843.          return var2 != null ? var2.isExpanded() : false;
  844.       }
  845.    }
  846.  
  847.    public boolean isCollapsed(TreePath var1) {
  848.       return !this.isExpanded(var1);
  849.    }
  850.  
  851.    public boolean isCollapsed(int var1) {
  852.       return !this.isExpanded(var1);
  853.    }
  854.  
  855.    public boolean isLeaf(int var1) {
  856.       if (!this.largeModel) {
  857.          VisibleTreeNode var2 = this.getNode(var1);
  858.          if (var2 != null) {
  859.             return var2.isLeaf();
  860.          }
  861.       } else {
  862.          if (var1 == 0 && this.isRootVisible()) {
  863.             return this.treeModel.isLeaf(this.treeModel.getRoot());
  864.          }
  865.  
  866.          int[] var4 = new int[1];
  867.          LargeTreeModelNode var3 = this.getLargeParentAndChildIndexOfRow(var1, var4);
  868.          if (var3 != null) {
  869.             return this.treeModel.isLeaf(this.treeModel.getChild(((DefaultMutableTreeNode)var3).getUserObject(), var4[0]));
  870.          }
  871.       }
  872.  
  873.       return true;
  874.    }
  875.  
  876.    public void makeVisible(TreePath var1) {
  877.       if (!this.largeModel) {
  878.          this.ensurePathIsExpanded(var1, false);
  879.       } else {
  880.          this.ensureLargePathIsExpanded(var1, false);
  881.       }
  882.    }
  883.  
  884.    public boolean isVisible(TreePath var1) {
  885.       if (!this.largeModel) {
  886.          VisibleTreeNode var2 = this.getNodeForTreePath(var1, true, false);
  887.          if (var2 != null) {
  888.             return true;
  889.          }
  890.       } else if (var1 != null) {
  891.          Object[] var6 = var1.getPath();
  892.          if (var6 != null) {
  893.             int var3 = var6.length;
  894.             if (var3 > 0) {
  895.                if (this.treeModel.isLeaf(var6[var3 - 1]) && var3 > 1) {
  896.                   Object[] var5 = new Object[var3 - 1];
  897.                   System.arraycopy(var6, 0, var5, 0, var3 - 1);
  898.                   LargeTreeModelNode var7 = this.getLargeTreeModelNodeForPath(var5, true, false);
  899.                   if (var7 != null && var7.isVisible() && var7.isExpanded()) {
  900.                      return true;
  901.                   }
  902.  
  903.                   return false;
  904.                }
  905.  
  906.                LargeTreeModelNode var4 = this.getLargeTreeModelNodeForPath(var6, true, false);
  907.                return var4.isVisible();
  908.             }
  909.          }
  910.       }
  911.  
  912.       return false;
  913.    }
  914.  
  915.    public int getRowCount() {
  916.       return !this.largeModel ? this.visibleNodes.size() : this.largeRowCount;
  917.    }
  918.  
  919.    public Rectangle getPathBounds(TreePath var1) {
  920.       if (!this.largeModel) {
  921.          VisibleTreeNode var2 = this.getNodeForTreePath(var1, true, false);
  922.          if (var2 != null) {
  923.             return var2.getNodeBounds();
  924.          }
  925.       } else if (var1 != null) {
  926.          return this.getRowBounds(this.getRowForPath(var1));
  927.       }
  928.  
  929.       return null;
  930.    }
  931.  
  932.    public Rectangle getRowBounds(int var1) {
  933.       if (var1 >= 0 && var1 < this.getRowCount()) {
  934.          if (!this.largeModel) {
  935.             return this.getNode(var1).getNodeBounds();
  936.          }
  937.  
  938.          if (var1 == 0 && this.isRootVisible()) {
  939.             return this.getLargeBoundsOf((LargeTreeModelNode)null, 0, this.largeRoot.getUserObject());
  940.          }
  941.  
  942.          int[] var2 = new int[1];
  943.          LargeTreeModelNode var3 = this.getLargeParentAndChildIndexOfRow(var1, var2);
  944.          if (var3 != null) {
  945.             return this.getLargeBoundsOf(var3, var1, this.treeModel.getChild(((DefaultMutableTreeNode)var3).getUserObject(), var2[0]));
  946.          }
  947.       }
  948.  
  949.       return null;
  950.    }
  951.  
  952.    public TreePath getPathForRow(int var1) {
  953.       if (var1 >= 0 && var1 < this.getRowCount()) {
  954.          return !this.largeModel ? this.getNode(var1).getTreePath() : this.getLargePathForRow(var1);
  955.       } else {
  956.          return null;
  957.       }
  958.    }
  959.  
  960.    public int getRowForPath(TreePath var1) {
  961.       if (var1 == null) {
  962.          return -1;
  963.       } else if (!this.largeModel) {
  964.          VisibleTreeNode var2 = this.getNodeForTreePath(var1, true, false);
  965.          return var2 != null ? var2.getRow() : -1;
  966.       } else {
  967.          return this.getLargeRowForPath(var1.getPath());
  968.       }
  969.    }
  970.  
  971.    public int[] getRowsForPaths(TreePath[] var1) {
  972.       if (var1 == null) {
  973.          return null;
  974.       } else {
  975.          int var2 = var1.length;
  976.          int[] var3 = new int[var2];
  977.  
  978.          for(int var4 = 0; var4 < var2; ++var4) {
  979.             var3[var4] = this.getRowForPath(var1[var4]);
  980.          }
  981.  
  982.          return var3;
  983.       }
  984.    }
  985.  
  986.    public TreePath[] getPathsForRows(int[] var1) {
  987.       if (var1 == null) {
  988.          return null;
  989.       } else {
  990.          int var2 = var1.length;
  991.          TreePath[] var3 = new TreePath[var2];
  992.  
  993.          for(int var4 = 0; var4 < var2; ++var4) {
  994.             var3[var4] = this.getPathForRow(var1[var4]);
  995.          }
  996.  
  997.          return var3;
  998.       }
  999.    }
  1000.  
  1001.    public void expandPath(TreePath var1) {
  1002.       if (var1 != null) {
  1003.          if (!this.largeModel) {
  1004.             this.ensurePathIsExpanded(var1, true);
  1005.             return;
  1006.          }
  1007.  
  1008.          this.ensureLargePathIsExpanded(var1, true);
  1009.       }
  1010.  
  1011.    }
  1012.  
  1013.    public void expandRow(int var1) {
  1014.       if (var1 >= 0 && var1 < this.getRowCount()) {
  1015.          if (!this.largeModel) {
  1016.             this.getNode(var1).expand();
  1017.             return;
  1018.          }
  1019.  
  1020.          LargeTreeModelNode var2 = this.getLargeTreeModelNodeForRow(var1, true);
  1021.          if (var2 != null) {
  1022.             var2.expand(true);
  1023.          }
  1024.       }
  1025.  
  1026.    }
  1027.  
  1028.    public void collapsePath(TreePath var1) {
  1029.       if (!this.largeModel) {
  1030.          VisibleTreeNode[] var2 = this.getNodesForTreePath(var1, false, true);
  1031.          if (var2 != null) {
  1032.             int var3 = 0;
  1033.  
  1034.             for(int var4 = var2.length - 1; var3 < var4; ++var3) {
  1035.                if (!var2[var3].isExpanded()) {
  1036.                   var2[var3].expand();
  1037.                }
  1038.             }
  1039.  
  1040.             if (var2.length > 0) {
  1041.                var2[var3].collapse();
  1042.                return;
  1043.             }
  1044.          }
  1045.       } else if (var1 != null) {
  1046.          LargeTreeModelNode var5 = this.getLargeTreeModelNodeForPath(var1.getPath(), false, true);
  1047.          if (var5 != null) {
  1048.             var5.collapse(true);
  1049.          }
  1050.       }
  1051.  
  1052.    }
  1053.  
  1054.    public void collapseRow(int var1) {
  1055.       if (var1 >= 0 && var1 < this.getRowCount()) {
  1056.          if (!this.largeModel) {
  1057.             this.getNode(var1).collapse();
  1058.             return;
  1059.          }
  1060.  
  1061.          LargeTreeModelNode var2 = this.getLargeTreeModelNodeForRow(var1, false);
  1062.          if (var2 != null) {
  1063.             var2.collapse(true);
  1064.          }
  1065.       }
  1066.  
  1067.    }
  1068.  
  1069.    public TreePath getClosestPathForLocation(int var1, int var2) {
  1070.       if (this.getRowCount() == 0) {
  1071.          return null;
  1072.       } else {
  1073.          int var3 = this.getRowContainingYLocation(var2);
  1074.          return !this.largeModel ? this.getNode(var3).getTreePath() : this.getLargePathForRow(var3);
  1075.       }
  1076.    }
  1077.  
  1078.    public int getClosestRowForLocation(int var1, int var2) {
  1079.       return this.getRowCount() == 0 ? -1 : this.getRowContainingYLocation(var2);
  1080.    }
  1081.  
  1082.    public Object getValue(int var1) {
  1083.       if (!this.largeModel) {
  1084.          return this.getNode(var1).getValue();
  1085.       } else {
  1086.          int[] var2 = new int[1];
  1087.          LargeTreeModelNode var3 = this.getLargeParentAndChildIndexOfRow(var1, var2);
  1088.          if (var1 == 0 && this.isRootVisible()) {
  1089.             return this.treeModel.getRoot();
  1090.          } else {
  1091.             return var3 != null ? this.treeModel.getChild(((DefaultMutableTreeNode)var3).getUserObject(), var2[0]) : null;
  1092.          }
  1093.       }
  1094.    }
  1095.  
  1096.    public VisibleTreeNode getNode(int var1) {
  1097.       return (VisibleTreeNode)this.visibleNodes.elementAt(var1);
  1098.    }
  1099.  
  1100.    public Enumeration visibleNodes() {
  1101.       return this.visibleNodes.elements();
  1102.    }
  1103.  
  1104.    public int getMaxNodeWidth() {
  1105.       int var1 = 0;
  1106.       if (!this.largeModel) {
  1107.          for(int var2 = this.getRowCount() - 1; var2 >= 0; --var2) {
  1108.             VisibleTreeNode var4 = this.getNode(var2);
  1109.             int var3;
  1110.             if ((var3 = var4.getPreferredSize().width + this.getXOriginOfNode(var4)) > var1) {
  1111.                var1 = var3;
  1112.             }
  1113.          }
  1114.       } else {
  1115.          for(int var6 = this.getRowCount() - 1; var6 >= 0; --var6) {
  1116.             Rectangle var5 = this.getRowBounds(var6);
  1117.             var1 = Math.max(var1, var5.x + var5.width);
  1118.          }
  1119.       }
  1120.  
  1121.       return var1;
  1122.    }
  1123.  
  1124.    public void setSelectionModel(TreeSelectionModel var1) {
  1125.       if (this.treeSelectionModel != var1) {
  1126.          if (this.treeSelectionModel != null) {
  1127.             this.treeSelectionModel.removeTreeSelectionListener(this);
  1128.             this.treeSelectionModel.setRowMapper((RowMapper)null);
  1129.          }
  1130.  
  1131.          this.treeSelectionModel = var1;
  1132.          if (this.treeSelectionModel != null) {
  1133.             this.treeSelectionModel.addTreeSelectionListener(this);
  1134.             this.treeSelectionModel.setRowMapper(this);
  1135.             this.treeSelectionModel.resetRowSelection();
  1136.          }
  1137.       }
  1138.  
  1139.    }
  1140.  
  1141.    public TreeSelectionModel getSelectionModel() {
  1142.       return this.treeSelectionModel;
  1143.    }
  1144.  
  1145.    public boolean isSelectedIndex(int var1) {
  1146.       return this.treeSelectionModel != null ? this.treeSelectionModel.isRowSelected(var1) : false;
  1147.    }
  1148.  
  1149.    public void valueChanged(TreeSelectionEvent var1) {
  1150.       if (this.treeSelectionModel != null) {
  1151.          TreePath[] var2 = this.treeSelectionModel.getSelectionPaths();
  1152.          if (var2 != null) {
  1153.             for(int var3 = var2.length - 1; var3 >= 0; --var3) {
  1154.                this.makeVisible(var2[var3]);
  1155.             }
  1156.          }
  1157.       }
  1158.  
  1159.    }
  1160.  
  1161.    protected VisibleTreeNode createNodeForValue(Object var1, int var2) {
  1162.       return new VisibleTreeNode(this, var1, var2);
  1163.    }
  1164.  
  1165.    protected LargeTreeModelNode createLargeTreeModelNodeForValue(Object var1, int var2) {
  1166.       return new LargeTreeModelNode(this, var1, var2);
  1167.    }
  1168.  
  1169.    protected LargeTreeModelNode getLargeParentAndChildIndexOfRow(int var1, int[] var2) {
  1170.       int[] var3 = new int[1];
  1171.       LargeTreeModelNode[] var4 = new LargeTreeModelNode[1];
  1172.       boolean[] var5 = new boolean[1];
  1173.       if (this.isRootVisible()) {
  1174.          var3[0] = 0;
  1175.       } else {
  1176.          var3[0] = -1;
  1177.       }
  1178.  
  1179.       if (this.largeRoot.getPathForRow(var1, var3, (TreePath[])null, var4, var5, var2)) {
  1180.          if (var5[0]) {
  1181.             return var4[0];
  1182.          } else {
  1183.             var2[0] = var4[0].getChildIndex();
  1184.             return (LargeTreeModelNode)var4[0].getParent();
  1185.          }
  1186.       } else {
  1187.          return null;
  1188.       }
  1189.    }
  1190.  
  1191.    protected LargeTreeModelNode getLargeTreeModelNodeForRow(int var1, boolean var2) {
  1192.       int[] var3 = new int[1];
  1193.       int[] var4 = new int[1];
  1194.       LargeTreeModelNode[] var5 = new LargeTreeModelNode[1];
  1195.       boolean[] var6 = new boolean[1];
  1196.       if (this.isRootVisible()) {
  1197.          var3[0] = 0;
  1198.       } else {
  1199.          var3[0] = -1;
  1200.       }
  1201.  
  1202.       if (this.largeRoot.getPathForRow(var1, var3, (TreePath[])null, var5, var6, var4)) {
  1203.          if (var6[0]) {
  1204.             if (var2) {
  1205.                Object var7 = this.treeModel.getChild(var5[0].getUserObject(), var4[0]);
  1206.                if (this.treeModel.isLeaf(var7)) {
  1207.                   return null;
  1208.                } else {
  1209.                   LargeTreeModelNode var8 = this.createLargeTreeModelNodeForValue(var7, var4[0]);
  1210.                   var5[0].addLargeTreeModelNode(var8);
  1211.                   return var8;
  1212.                }
  1213.             } else {
  1214.                return null;
  1215.             }
  1216.          } else {
  1217.             return var5[0];
  1218.          }
  1219.       } else {
  1220.          return null;
  1221.       }
  1222.    }
  1223.  
  1224.    protected TreePath getLargePathForRow(int var1) {
  1225.       int[] var2 = new int[1];
  1226.       TreePath[] var3 = new TreePath[1];
  1227.       if (this.isRootVisible()) {
  1228.          var2[0] = 0;
  1229.       } else {
  1230.          var2[0] = -1;
  1231.       }
  1232.  
  1233.       return this.largeRoot.getPathForRow(var1, var2, var3, (LargeTreeModelNode[])null, (boolean[])null, (int[])null) ? var3[0] : null;
  1234.    }
  1235.  
  1236.    protected int getLargeRowForPath(Object[] var1) {
  1237.       int[] var2 = new int[1];
  1238.       if (this.isRootVisible()) {
  1239.          var2[0] = 0;
  1240.       } else {
  1241.          var2[0] = -1;
  1242.       }
  1243.  
  1244.       return var1 != null && this.largeRoot.getRow(var1, 0, var1.length, true, var2) ? var2[0] : -1;
  1245.    }
  1246.  
  1247.    protected LargeTreeModelNode getLargeTreeModelNodeForPath(Object[] var1, boolean var2, boolean var3) {
  1248.       if (var1 != null) {
  1249.          int var4 = var1.length;
  1250.          if (var4 > 0) {
  1251.             return this.getLargeTreeModelNodeForPath(var1, var2, var3, var4);
  1252.          }
  1253.       }
  1254.  
  1255.       return null;
  1256.    }
  1257.  
  1258.    protected LargeTreeModelNode getLargeTreeModelNodeForPath(Object[] var1, boolean var2, boolean var3, int var4) {
  1259.       if (!var1[0].equals(this.largeRoot.getUserObject())) {
  1260.          return null;
  1261.       } else {
  1262.          LargeTreeModelNode var7 = this.largeRoot;
  1263.  
  1264.          for(int var11 = 1; var11 < var4; ++var11) {
  1265.             if (var2 && !var7.isExpanded) {
  1266.                return null;
  1267.             }
  1268.  
  1269.             int var10 = this.treeModel.getIndexOfChild(((DefaultMutableTreeNode)var7).getUserObject(), var1[var11]);
  1270.             if (var10 < 0) {
  1271.                throw new RuntimeException("invalid index " + var10 + " for path " + var1[var11]);
  1272.             }
  1273.  
  1274.             int var9 = ((DefaultMutableTreeNode)var7).getChildCount();
  1275.             LargeTreeModelNode var6 = var7;
  1276.  
  1277.             for(int var8 = 0; var8 < var9; ++var8) {
  1278.                LargeTreeModelNode var5 = (LargeTreeModelNode)((DefaultMutableTreeNode)var7).getChildAt(var8);
  1279.                if (var5.childIndex == var10) {
  1280.                   var7 = var5;
  1281.                   var8 = var9;
  1282.                } else if (var5.childIndex > var10) {
  1283.                   if (!var3) {
  1284.                      return null;
  1285.                   }
  1286.  
  1287.                   LargeTreeModelNode var12 = this.createLargeTreeModelNodeForValue(var1[var11], var10);
  1288.                   ((DefaultMutableTreeNode)var7).insert(var12, var8);
  1289.                   var7 = var12;
  1290.                   var8 = var9;
  1291.                }
  1292.             }
  1293.  
  1294.             if (var6 == var7) {
  1295.                if (!var3) {
  1296.                   return null;
  1297.                }
  1298.  
  1299.                LargeTreeModelNode var13 = this.createLargeTreeModelNodeForValue(var1[var11], var10);
  1300.                ((DefaultMutableTreeNode)var7).add(var13);
  1301.                var7 = var13;
  1302.             }
  1303.          }
  1304.  
  1305.          return var7;
  1306.       }
  1307.    }
  1308.  
  1309.    protected AbstractTreePath createTreePathFor(VisibleTreeNode var1) {
  1310.       return new AbstractTreePath(((DefaultMutableTreeNode)var1).getUserObjectPath(), var1);
  1311.    }
  1312.  
  1313.    private void writeObject(ObjectOutputStream var1) throws IOException {
  1314.       Vector var2 = new Vector();
  1315.       var1.defaultWriteObject();
  1316.       if (this.treeModel != null && this.treeModel instanceof Serializable) {
  1317.          var2.addElement("treeModel");
  1318.          var2.addElement(this.treeModel);
  1319.       }
  1320.  
  1321.       if (this.treeSelectionModel != null && this.treeSelectionModel instanceof Serializable) {
  1322.          var2.addElement("treeSelectionModel");
  1323.          var2.addElement(this.treeSelectionModel);
  1324.       }
  1325.  
  1326.       var1.writeObject(var2);
  1327.    }
  1328.  
  1329.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  1330.       var1.defaultReadObject();
  1331.       Vector var2 = (Vector)var1.readObject();
  1332.       int var3 = 0;
  1333.       int var4 = var2.size();
  1334.       if (var3 < var4 && var2.elementAt(var3).equals("treeModel")) {
  1335.          ++var3;
  1336.          this.treeModel = (TreeModel)var2.elementAt(var3);
  1337.          ++var3;
  1338.       }
  1339.  
  1340.       if (var3 < var4 && var2.elementAt(var3).equals("treeSelectionModel")) {
  1341.          ++var3;
  1342.          this.treeSelectionModel = (TreeSelectionModel)var2.elementAt(var3);
  1343.          ++var3;
  1344.       }
  1345.  
  1346.    }
  1347. }
  1348.