home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &… the Search for Life CD 3 / 0_CD-ROM.iso / install / jre1_3 / lib / rt.jar / javax / swing / tree / DefaultTreeSelectionModel.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  9.8 KB  |  756 lines
  1. package javax.swing.tree;
  2.  
  3. import java.beans.PropertyChangeListener;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.io.Serializable;
  8. import java.util.BitSet;
  9. import java.util.Enumeration;
  10. import java.util.EventListener;
  11. import java.util.Hashtable;
  12. import java.util.Vector;
  13. import javax.swing.DefaultListSelectionModel;
  14. import javax.swing.event.EventListenerList;
  15. import javax.swing.event.SwingPropertyChangeSupport;
  16. import javax.swing.event.TreeSelectionEvent;
  17. import javax.swing.event.TreeSelectionListener;
  18.  
  19. public class DefaultTreeSelectionModel implements Cloneable, Serializable, TreeSelectionModel {
  20.    public static final String SELECTION_MODE_PROPERTY = "selectionMode";
  21.    protected SwingPropertyChangeSupport changeSupport;
  22.    protected TreePath[] selection;
  23.    protected EventListenerList listenerList = new EventListenerList();
  24.    protected transient RowMapper rowMapper;
  25.    protected DefaultListSelectionModel listSelectionModel = new DefaultListSelectionModel();
  26.    protected int selectionMode = 4;
  27.    protected TreePath leadPath;
  28.    protected int leadIndex;
  29.    protected int leadRow;
  30.    private Hashtable uniquePaths;
  31.    private Hashtable lastPaths;
  32.    private TreePath[] tempPaths;
  33.    // $FF: synthetic field
  34.    static Class class$javax$swing$event$TreeSelectionListener;
  35.  
  36.    public DefaultTreeSelectionModel() {
  37.       this.leadIndex = this.leadRow = -1;
  38.       this.uniquePaths = new Hashtable();
  39.       this.lastPaths = new Hashtable();
  40.       this.tempPaths = new TreePath[1];
  41.    }
  42.  
  43.    public void setRowMapper(RowMapper var1) {
  44.       this.rowMapper = var1;
  45.       this.resetRowSelection();
  46.    }
  47.  
  48.    public RowMapper getRowMapper() {
  49.       return this.rowMapper;
  50.    }
  51.  
  52.    public void setSelectionMode(int var1) {
  53.       int var2 = this.selectionMode;
  54.       this.selectionMode = var1;
  55.       if (this.selectionMode != 1 && this.selectionMode != 2 && this.selectionMode != 4) {
  56.          this.selectionMode = 4;
  57.       }
  58.  
  59.       if (var2 != this.selectionMode && this.changeSupport != null) {
  60.          this.changeSupport.firePropertyChange("selectionMode", new Integer(var2), new Integer(this.selectionMode));
  61.       }
  62.  
  63.    }
  64.  
  65.    public int getSelectionMode() {
  66.       return this.selectionMode;
  67.    }
  68.  
  69.    public void setSelectionPath(TreePath var1) {
  70.       if (var1 == null) {
  71.          this.setSelectionPaths((TreePath[])null);
  72.       } else {
  73.          TreePath[] var2 = new TreePath[]{var1};
  74.          this.setSelectionPaths(var2);
  75.       }
  76.  
  77.    }
  78.  
  79.    public void setSelectionPaths(TreePath[] var1) {
  80.       TreePath[] var6 = var1;
  81.       int var2;
  82.       if (var1 == null) {
  83.          var2 = 0;
  84.       } else {
  85.          var2 = var1.length;
  86.       }
  87.  
  88.       int var4;
  89.       if (this.selection == null) {
  90.          var4 = 0;
  91.       } else {
  92.          var4 = this.selection.length;
  93.       }
  94.  
  95.       if (var2 + var4 != 0) {
  96.          if (this.selectionMode == 1) {
  97.             if (var2 > 1) {
  98.                var6 = new TreePath[]{var1[0]};
  99.                var2 = 1;
  100.             }
  101.          } else if (this.selectionMode == 2 && var2 > 0 && !this.arePathsContiguous(var1)) {
  102.             var6 = new TreePath[]{var1[0]};
  103.             var2 = 1;
  104.          }
  105.  
  106.          int var7 = 0;
  107.          TreePath var8 = this.leadPath;
  108.          Vector var9 = new Vector(var2 + var4);
  109.          this.lastPaths.clear();
  110.          this.leadPath = null;
  111.  
  112.          for(int var3 = 0; var3 < var2; ++var3) {
  113.             if (var6[var3] != null && this.lastPaths.get(var6[var3]) == null) {
  114.                ++var7;
  115.                this.lastPaths.put(var6[var3], Boolean.TRUE);
  116.                if (this.uniquePaths.get(var6[var3]) == null) {
  117.                   var9.addElement(new PathPlaceHolder(var6[var3], true));
  118.                }
  119.  
  120.                this.leadPath = var6[var3];
  121.             }
  122.          }
  123.  
  124.          TreePath[] var10;
  125.          if (var7 == 0) {
  126.             var10 = null;
  127.          } else if (var7 != var2) {
  128.             Enumeration var11 = this.lastPaths.keys();
  129.             var10 = new TreePath[var7];
  130.  
  131.             for(int var12 = 0; var11.hasMoreElements(); var10[var12++] = (TreePath)var11.nextElement()) {
  132.             }
  133.          } else {
  134.             var10 = new TreePath[var6.length];
  135.             System.arraycopy(var6, 0, var10, 0, var6.length);
  136.          }
  137.  
  138.          for(int var5 = 0; var5 < var4; ++var5) {
  139.             if (this.selection[var5] != null && this.lastPaths.get(this.selection[var5]) == null) {
  140.                var9.addElement(new PathPlaceHolder(this.selection[var5], false));
  141.             }
  142.          }
  143.  
  144.          this.selection = var10;
  145.          Hashtable var13 = this.uniquePaths;
  146.          this.uniquePaths = this.lastPaths;
  147.          this.lastPaths = var13;
  148.          this.lastPaths.clear();
  149.          if (this.selection != null) {
  150.             this.insureUniqueness();
  151.          }
  152.  
  153.          this.updateLeadIndex();
  154.          this.resetRowSelection();
  155.          if (var9.size() > 0) {
  156.             this.notifyPathChange(var9, var8);
  157.          }
  158.       }
  159.  
  160.    }
  161.  
  162.    public void addSelectionPath(TreePath var1) {
  163.       if (var1 != null) {
  164.          TreePath[] var2 = new TreePath[]{var1};
  165.          this.addSelectionPaths(var2);
  166.       }
  167.  
  168.    }
  169.  
  170.    public void addSelectionPaths(TreePath[] var1) {
  171.       int var2 = var1 == null ? 0 : var1.length;
  172.       if (var2 > 0) {
  173.          if (this.selectionMode == 1) {
  174.             this.setSelectionPaths(var1);
  175.          } else if (this.selectionMode == 2 && !this.canPathsBeAdded(var1)) {
  176.             if (this.arePathsContiguous(var1)) {
  177.                this.setSelectionPaths(var1);
  178.             } else {
  179.                TreePath[] var11 = new TreePath[]{var1[0]};
  180.                this.setSelectionPaths(var11);
  181.             }
  182.          } else {
  183.             TreePath var6 = this.leadPath;
  184.             Vector var7 = null;
  185.             int var5;
  186.             if (this.selection == null) {
  187.                var5 = 0;
  188.             } else {
  189.                var5 = this.selection.length;
  190.             }
  191.  
  192.             this.lastPaths.clear();
  193.             int var3 = 0;
  194.  
  195.             int var4;
  196.             for(var4 = 0; var3 < var2; ++var3) {
  197.                if (var1[var3] != null) {
  198.                   if (this.uniquePaths.get(var1[var3]) == null) {
  199.                      ++var4;
  200.                      if (var7 == null) {
  201.                         var7 = new Vector();
  202.                      }
  203.  
  204.                      var7.addElement(new PathPlaceHolder(var1[var3], true));
  205.                      this.uniquePaths.put(var1[var3], Boolean.TRUE);
  206.                      this.lastPaths.put(var1[var3], Boolean.TRUE);
  207.                   }
  208.  
  209.                   this.leadPath = var1[var3];
  210.                }
  211.             }
  212.  
  213.             if (this.leadPath == null) {
  214.                this.leadPath = var6;
  215.             }
  216.  
  217.             if (var4 > 0) {
  218.                TreePath[] var8 = new TreePath[var5 + var4];
  219.                if (var5 > 0) {
  220.                   System.arraycopy(this.selection, 0, var8, 0, var5);
  221.                }
  222.  
  223.                if (var4 != var1.length) {
  224.                   Enumeration var9 = this.lastPaths.keys();
  225.  
  226.                   for(int var10 = var5; var9.hasMoreElements(); var8[var10++] = (TreePath)var9.nextElement()) {
  227.                   }
  228.                } else {
  229.                   System.arraycopy(var1, 0, var8, var5, var4);
  230.                }
  231.  
  232.                this.selection = var8;
  233.                this.insureUniqueness();
  234.                this.updateLeadIndex();
  235.                this.resetRowSelection();
  236.                this.notifyPathChange(var7, var6);
  237.             } else {
  238.                this.leadPath = var6;
  239.             }
  240.  
  241.             this.lastPaths.clear();
  242.          }
  243.       }
  244.  
  245.    }
  246.  
  247.    public void removeSelectionPath(TreePath var1) {
  248.       if (var1 != null) {
  249.          TreePath[] var2 = new TreePath[]{var1};
  250.          this.removeSelectionPaths(var2);
  251.       }
  252.  
  253.    }
  254.  
  255.    public void removeSelectionPaths(TreePath[] var1) {
  256.       if (var1 != null && this.selection != null && var1.length > 0) {
  257.          if (!this.canPathsBeRemoved(var1)) {
  258.             this.clearSelection();
  259.          } else {
  260.             Vector var2 = null;
  261.  
  262.             for(int var3 = var1.length - 1; var3 >= 0; --var3) {
  263.                if (var1[var3] != null && this.uniquePaths.get(var1[var3]) != null) {
  264.                   if (var2 == null) {
  265.                      var2 = new Vector(var1.length);
  266.                   }
  267.  
  268.                   this.uniquePaths.remove(var1[var3]);
  269.                   var2.addElement(new PathPlaceHolder(var1[var3], false));
  270.                }
  271.             }
  272.  
  273.             if (var2 != null) {
  274.                int var4 = var2.size();
  275.                TreePath var5 = this.leadPath;
  276.                if (var4 == this.selection.length) {
  277.                   this.selection = null;
  278.                } else {
  279.                   Enumeration var6 = this.uniquePaths.keys();
  280.                   int var7 = 0;
  281.  
  282.                   for(this.selection = new TreePath[this.selection.length - var4]; var6.hasMoreElements(); this.selection[var7++] = (TreePath)var6.nextElement()) {
  283.                   }
  284.                }
  285.  
  286.                if (this.leadPath != null && this.uniquePaths.get(this.leadPath) == null) {
  287.                   if (this.selection != null) {
  288.                      this.leadPath = this.selection[this.selection.length - 1];
  289.                   } else {
  290.                      this.leadPath = null;
  291.                   }
  292.                } else if (this.selection != null) {
  293.                   this.leadPath = this.selection[this.selection.length - 1];
  294.                } else {
  295.                   this.leadPath = null;
  296.                }
  297.  
  298.                this.updateLeadIndex();
  299.                this.resetRowSelection();
  300.                this.notifyPathChange(var2, var5);
  301.             }
  302.          }
  303.       }
  304.  
  305.    }
  306.  
  307.    public TreePath getSelectionPath() {
  308.       return this.selection != null ? this.selection[0] : null;
  309.    }
  310.  
  311.    public TreePath[] getSelectionPaths() {
  312.       if (this.selection != null) {
  313.          int var1 = this.selection.length;
  314.          TreePath[] var2 = new TreePath[var1];
  315.          System.arraycopy(this.selection, 0, var2, 0, var1);
  316.          return var2;
  317.       } else {
  318.          return null;
  319.       }
  320.    }
  321.  
  322.    public int getSelectionCount() {
  323.       return this.selection == null ? 0 : this.selection.length;
  324.    }
  325.  
  326.    public boolean isPathSelected(TreePath var1) {
  327.       return var1 != null ? this.uniquePaths.get(var1) != null : false;
  328.    }
  329.  
  330.    public boolean isSelectionEmpty() {
  331.       return this.selection == null;
  332.    }
  333.  
  334.    public void clearSelection() {
  335.       if (this.selection != null) {
  336.          int var1 = this.selection.length;
  337.          boolean[] var2 = new boolean[var1];
  338.  
  339.          for(int var3 = 0; var3 < var1; ++var3) {
  340.             var2[var3] = false;
  341.          }
  342.  
  343.          TreeSelectionEvent var4 = new TreeSelectionEvent(this, this.selection, var2, this.leadPath, (TreePath)null);
  344.          this.leadPath = null;
  345.          this.leadIndex = this.leadRow = -1;
  346.          this.uniquePaths.clear();
  347.          this.selection = null;
  348.          this.resetRowSelection();
  349.          this.fireValueChanged(var4);
  350.       }
  351.  
  352.    }
  353.  
  354.    public void addTreeSelectionListener(TreeSelectionListener var1) {
  355.       this.listenerList.add(class$javax$swing$event$TreeSelectionListener == null ? (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")) : class$javax$swing$event$TreeSelectionListener, var1);
  356.    }
  357.  
  358.    public void removeTreeSelectionListener(TreeSelectionListener var1) {
  359.       this.listenerList.remove(class$javax$swing$event$TreeSelectionListener == null ? (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")) : class$javax$swing$event$TreeSelectionListener, var1);
  360.    }
  361.  
  362.    protected void fireValueChanged(TreeSelectionEvent var1) {
  363.       Object[] var2 = this.listenerList.getListenerList();
  364.  
  365.       for(int var3 = var2.length - 2; var3 >= 0; var3 -= 2) {
  366.          if (var2[var3] == (class$javax$swing$event$TreeSelectionListener == null ? (class$javax$swing$event$TreeSelectionListener = class$("javax.swing.event.TreeSelectionListener")) : class$javax$swing$event$TreeSelectionListener)) {
  367.             ((TreeSelectionListener)var2[var3 + 1]).valueChanged(var1);
  368.          }
  369.       }
  370.  
  371.    }
  372.  
  373.    public EventListener[] getListeners(Class var1) {
  374.       return this.listenerList.getListeners(var1);
  375.    }
  376.  
  377.    public int[] getSelectionRows() {
  378.       if (this.rowMapper != null && this.selection != null) {
  379.          int[] var1 = this.rowMapper.getRowsForPaths(this.selection);
  380.          if (var1 != null) {
  381.             int var2 = 0;
  382.  
  383.             for(int var3 = var1.length - 1; var3 >= 0; --var3) {
  384.                if (var1[var3] == -1) {
  385.                   ++var2;
  386.                }
  387.             }
  388.  
  389.             if (var2 > 0) {
  390.                if (var2 == var1.length) {
  391.                   var1 = null;
  392.                } else {
  393.                   int[] var4 = new int[var1.length - var2];
  394.                   int var5 = var1.length - 1;
  395.  
  396.                   for(int var6 = 0; var5 >= 0; --var5) {
  397.                      if (var1[var5] != -1) {
  398.                         var4[var6++] = var1[var5];
  399.                      }
  400.                   }
  401.  
  402.                   var1 = var4;
  403.                }
  404.             }
  405.          }
  406.  
  407.          return var1;
  408.       } else {
  409.          return null;
  410.       }
  411.    }
  412.  
  413.    public int getMinSelectionRow() {
  414.       return this.listSelectionModel.getMinSelectionIndex();
  415.    }
  416.  
  417.    public int getMaxSelectionRow() {
  418.       return this.listSelectionModel.getMaxSelectionIndex();
  419.    }
  420.  
  421.    public boolean isRowSelected(int var1) {
  422.       return this.listSelectionModel.isSelectedIndex(var1);
  423.    }
  424.  
  425.    public void resetRowSelection() {
  426.       this.listSelectionModel.clearSelection();
  427.       if (this.selection != null && this.rowMapper != null) {
  428.          boolean var2 = false;
  429.          int[] var3 = this.rowMapper.getRowsForPaths(this.selection);
  430.          int var4 = 0;
  431.  
  432.          for(int var5 = this.selection.length; var4 < var5; ++var4) {
  433.             int var1 = var3[var4];
  434.             if (var1 != -1) {
  435.                this.listSelectionModel.addSelectionInterval(var1, var1);
  436.             }
  437.          }
  438.  
  439.          if (this.leadIndex != -1 && var3 != null) {
  440.             this.leadRow = var3[this.leadIndex];
  441.          } else if (this.leadPath != null) {
  442.             this.tempPaths[0] = this.leadPath;
  443.             var3 = this.rowMapper.getRowsForPaths(this.tempPaths);
  444.             this.leadRow = var3 != null ? var3[0] : -1;
  445.          } else {
  446.             this.leadRow = -1;
  447.          }
  448.  
  449.          this.insureRowContinuity();
  450.       } else {
  451.          this.leadRow = -1;
  452.       }
  453.  
  454.    }
  455.  
  456.    public int getLeadSelectionRow() {
  457.       return this.leadRow;
  458.    }
  459.  
  460.    public TreePath getLeadSelectionPath() {
  461.       return this.leadPath;
  462.    }
  463.  
  464.    public synchronized void addPropertyChangeListener(PropertyChangeListener var1) {
  465.       if (this.changeSupport == null) {
  466.          this.changeSupport = new SwingPropertyChangeSupport(this);
  467.       }
  468.  
  469.       this.changeSupport.addPropertyChangeListener(var1);
  470.    }
  471.  
  472.    public synchronized void removePropertyChangeListener(PropertyChangeListener var1) {
  473.       if (this.changeSupport != null) {
  474.          this.changeSupport.removePropertyChangeListener(var1);
  475.       }
  476.    }
  477.  
  478.    protected void insureRowContinuity() {
  479.       if (this.selectionMode == 2 && this.selection != null && this.rowMapper != null) {
  480.          DefaultListSelectionModel var1 = this.listSelectionModel;
  481.          int var2 = var1.getMinSelectionIndex();
  482.          if (var2 != -1) {
  483.             int var3 = var2;
  484.  
  485.             for(int var4 = var1.getMaxSelectionIndex(); var3 <= var4; ++var3) {
  486.                if (!var1.isSelectedIndex(var3)) {
  487.                   if (var3 != var2) {
  488.                      TreePath[] var5 = new TreePath[var3 - var2];
  489.                      System.arraycopy(this.selection, 0, var5, 0, var3 - var2);
  490.                      this.setSelectionPaths(var5);
  491.                      break;
  492.                   }
  493.  
  494.                   this.clearSelection();
  495.                }
  496.             }
  497.          }
  498.       } else if (this.selectionMode == 1 && this.selection != null && this.selection.length > 1) {
  499.          this.setSelectionPath(this.selection[0]);
  500.       }
  501.  
  502.    }
  503.  
  504.    protected boolean arePathsContiguous(TreePath[] var1) {
  505.       if (this.rowMapper != null && var1.length >= 2) {
  506.          BitSet var2 = new BitSet(32);
  507.          int var6 = var1.length;
  508.          int var7 = 0;
  509.          TreePath[] var8 = new TreePath[]{var1[0]};
  510.          int var5 = this.rowMapper.getRowsForPaths(var8)[0];
  511.  
  512.          for(int var4 = 0; var4 < var6; ++var4) {
  513.             if (var1[var4] != null) {
  514.                var8[0] = var1[var4];
  515.                int[] var9 = this.rowMapper.getRowsForPaths(var8);
  516.                if (var9 == null) {
  517.                   return false;
  518.                }
  519.  
  520.                int var3 = var9[0];
  521.                if (var3 == -1 || var3 < var5 - var6 || var3 > var5 + var6) {
  522.                   return false;
  523.                }
  524.  
  525.                if (var3 < var5) {
  526.                   var5 = var3;
  527.                }
  528.  
  529.                if (!var2.get(var3)) {
  530.                   var2.set(var3);
  531.                   ++var7;
  532.                }
  533.             }
  534.          }
  535.  
  536.          int var11 = var7 + var5;
  537.  
  538.          for(int var10 = var5; var10 < var11; ++var10) {
  539.             if (!var2.get(var10)) {
  540.                return false;
  541.             }
  542.          }
  543.  
  544.          return true;
  545.       } else {
  546.          return true;
  547.       }
  548.    }
  549.  
  550.    protected boolean canPathsBeAdded(TreePath[] var1) {
  551.       if (var1 != null && var1.length != 0 && this.rowMapper != null && this.selection != null && this.selectionMode != 4) {
  552.          BitSet var2 = new BitSet();
  553.          DefaultListSelectionModel var3 = this.listSelectionModel;
  554.          int var6 = var3.getMinSelectionIndex();
  555.          int var7 = var3.getMaxSelectionIndex();
  556.          TreePath[] var8 = new TreePath[1];
  557.          if (var6 != -1) {
  558.             for(int var5 = var6; var5 <= var7; ++var5) {
  559.                if (var3.isSelectedIndex(var5)) {
  560.                   var2.set(var5);
  561.                }
  562.             }
  563.          } else {
  564.             var8[0] = var1[0];
  565.             var6 = var7 = this.rowMapper.getRowsForPaths(var8)[0];
  566.          }
  567.  
  568.          for(int var10 = var1.length - 1; var10 >= 0; --var10) {
  569.             if (var1[var10] != null) {
  570.                var8[0] = var1[var10];
  571.                int[] var9 = this.rowMapper.getRowsForPaths(var8);
  572.                if (var9 == null) {
  573.                   return false;
  574.                }
  575.  
  576.                int var4 = var9[0];
  577.                var6 = Math.min(var4, var6);
  578.                var7 = Math.max(var4, var7);
  579.                if (var4 == -1) {
  580.                   return false;
  581.                }
  582.  
  583.                var2.set(var4);
  584.             }
  585.          }
  586.  
  587.          for(int var11 = var6; var11 <= var7; ++var11) {
  588.             if (!var2.get(var11)) {
  589.                return false;
  590.             }
  591.          }
  592.  
  593.          return true;
  594.       } else {
  595.          return true;
  596.       }
  597.    }
  598.  
  599.    protected boolean canPathsBeRemoved(TreePath[] var1) {
  600.       if (this.rowMapper != null && this.selection != null && this.selectionMode != 4) {
  601.          BitSet var2 = new BitSet();
  602.          int var4 = var1.length;
  603.          int var6 = -1;
  604.          int var7 = 0;
  605.          TreePath[] var8 = new TreePath[1];
  606.          this.lastPaths.clear();
  607.  
  608.          for(int var3 = 0; var3 < var4; ++var3) {
  609.             if (var1[var3] != null) {
  610.                this.lastPaths.put(var1[var3], Boolean.TRUE);
  611.             }
  612.          }
  613.  
  614.          for(int var10 = this.selection.length - 1; var10 >= 0; --var10) {
  615.             if (this.lastPaths.get(this.selection[var10]) == null) {
  616.                var8[0] = this.selection[var10];
  617.                int[] var9 = this.rowMapper.getRowsForPaths(var8);
  618.                if (var9 != null && var9[0] != -1 && !var2.get(var9[0])) {
  619.                   ++var7;
  620.                   if (var6 == -1) {
  621.                      var6 = var9[0];
  622.                   } else {
  623.                      var6 = Math.min(var6, var9[0]);
  624.                   }
  625.  
  626.                   var2.set(var9[0]);
  627.                }
  628.             }
  629.          }
  630.  
  631.          this.lastPaths.clear();
  632.          if (var7 > 1) {
  633.             for(int var11 = var6 + var7 - 1; var11 >= var6; --var11) {
  634.                if (!var2.get(var11)) {
  635.                   return false;
  636.                }
  637.             }
  638.          }
  639.  
  640.          return true;
  641.       } else {
  642.          return true;
  643.       }
  644.    }
  645.  
  646.    protected void notifyPathChange(Vector var1, TreePath var2) {
  647.       int var3 = var1.size();
  648.       boolean[] var4 = new boolean[var3];
  649.       TreePath[] var5 = new TreePath[var3];
  650.  
  651.       for(int var7 = 0; var7 < var3; ++var7) {
  652.          PathPlaceHolder var6 = (PathPlaceHolder)var1.elementAt(var7);
  653.          var4[var7] = var6.isNew;
  654.          var5[var7] = var6.path;
  655.       }
  656.  
  657.       TreeSelectionEvent var8 = new TreeSelectionEvent(this, var5, var4, var2, this.leadPath);
  658.       this.fireValueChanged(var8);
  659.    }
  660.  
  661.    protected void updateLeadIndex() {
  662.       if (this.leadPath != null) {
  663.          if (this.selection == null) {
  664.             this.leadPath = null;
  665.             this.leadIndex = this.leadRow = -1;
  666.          } else {
  667.             this.leadRow = this.leadIndex = -1;
  668.  
  669.             for(int var1 = this.selection.length - 1; var1 >= 0; --var1) {
  670.                if (this.selection[var1] == this.leadPath) {
  671.                   this.leadIndex = var1;
  672.                   break;
  673.                }
  674.             }
  675.          }
  676.       } else {
  677.          this.leadIndex = -1;
  678.       }
  679.  
  680.    }
  681.  
  682.    protected void insureUniqueness() {
  683.    }
  684.  
  685.    public String toString() {
  686.       int var1 = this.getSelectionCount();
  687.       StringBuffer var2 = new StringBuffer();
  688.       int[] var3;
  689.       if (this.rowMapper != null) {
  690.          var3 = this.rowMapper.getRowsForPaths(this.selection);
  691.       } else {
  692.          var3 = null;
  693.       }
  694.  
  695.       var2.append(this.getClass().getName() + " " + this.hashCode() + " [ ");
  696.  
  697.       for(int var4 = 0; var4 < var1; ++var4) {
  698.          if (var3 != null) {
  699.             var2.append(this.selection[var4].toString() + "@" + Integer.toString(var3[var4]) + " ");
  700.          } else {
  701.             var2.append(this.selection[var4].toString() + " ");
  702.          }
  703.       }
  704.  
  705.       var2.append("]");
  706.       return var2.toString();
  707.    }
  708.  
  709.    public Object clone() throws CloneNotSupportedException {
  710.       DefaultTreeSelectionModel var1 = (DefaultTreeSelectionModel)super.clone();
  711.       var1.changeSupport = null;
  712.       if (this.selection != null) {
  713.          int var2 = this.selection.length;
  714.          var1.selection = new TreePath[var2];
  715.          System.arraycopy(this.selection, 0, var1.selection, 0, var2);
  716.       }
  717.  
  718.       var1.listenerList = new EventListenerList();
  719.       var1.listSelectionModel = (DefaultListSelectionModel)this.listSelectionModel.clone();
  720.       var1.uniquePaths = new Hashtable();
  721.       var1.lastPaths = new Hashtable();
  722.       var1.tempPaths = new TreePath[1];
  723.       return var1;
  724.    }
  725.  
  726.    private void writeObject(ObjectOutputStream var1) throws IOException {
  727.       var1.defaultWriteObject();
  728.       Object[] var2;
  729.       if (this.rowMapper != null && this.rowMapper instanceof Serializable) {
  730.          var2 = new Object[]{"rowMapper", this.rowMapper};
  731.       } else {
  732.          var2 = new Object[0];
  733.       }
  734.  
  735.       var1.writeObject(var2);
  736.    }
  737.  
  738.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  739.       var1.defaultReadObject();
  740.       Object[] var2 = var1.readObject();
  741.       if (var2.length > 0 && var2[0].equals("rowMapper")) {
  742.          this.rowMapper = (RowMapper)var2[1];
  743.       }
  744.  
  745.    }
  746.  
  747.    // $FF: synthetic method
  748.    static Class class$(String var0) {
  749.       try {
  750.          return Class.forName(var0);
  751.       } catch (ClassNotFoundException var2) {
  752.          throw new NoClassDefFoundError(((Throwable)var2).getMessage());
  753.       }
  754.    }
  755. }
  756.