DefaultTreeSelectionModel


1   /*
2    * @(#)DefaultTreeSelectionModel.java   1.50 04/05/05
3    *
4    * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
5    * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
6    */
7   
8   package javax.swing.tree;
9   
10  import java.beans.PropertyChangeListener  ;
11  import java.io.*;
12  import java.util.BitSet  ;
13  import java.util.Enumeration  ;
14  import java.util.EventListener  ;
15  import java.util.Hashtable  ;
16  import java.util.Vector  ;
17  import javax.swing.event.*;
18  import javax.swing.DefaultListSelectionModel  ;
19  
20  /**
21   * Default implementation of TreeSelectionModel.  Listeners are notified
22   * whenever
23   * the paths in the selection change, not the rows. In order
24   * to be able to track row changes you may wish to become a listener 
25   * for expansion events on the tree and test for changes from there.
26   * <p>resetRowSelection is called from any of the methods that update
27   * the selected paths. If you subclass any of these methods to
28   * filter what is allowed to be selected, be sure and message
29   * <code>resetRowSelection</code> if you do not message super.
30   * 
31   * <p>
32   * 
33   * <strong>Warning:</strong>
34   * Serialized objects of this class will not be compatible with
35   * future Swing releases. The current serialization support is
36   * appropriate for short term storage or RMI between applications running
37   * the same version of Swing.  As of 1.4, support for long term storage
38   * of all JavaBeans<sup><font size="-2">TM</font></sup>
39   * has been added to the <code>java.beans</code> package.
40   * Please see {@link java.beans.XMLEncoder}.
41   *
42   * @see javax.swing.JTree
43   *
44   * @version 1.50 05/05/04
45   * @author Scott Violet
46   */
47  public class DefaultTreeSelectionModel extends Object   implements Cloneable  , Serializable, TreeSelectionModel  
48  {
49      /** Property name for selectionMode. */
50      public static final String            SELECTION_MODE_PROPERTY = "selectionMode";
51  
52      /** Used to messaged registered listeners. */
53      protected SwingPropertyChangeSupport     changeSupport;
54  
55      /** Paths that are currently selected.  Will be null if nothing is
56        * currently selected. */
57      protected TreePath  []                selection;
58  
59      /** Event listener list. */
60      protected EventListenerList   listenerList = new EventListenerList();
61  
62      /** Provides a row for a given path. */
63      transient protected RowMapper                 rowMapper;
64  
65      /** Handles maintaining the list selection model. The RowMapper is used
66       * to map from a TreePath to a row, and the value is then placed here. */
67      protected DefaultListSelectionModel       listSelectionModel;
68  
69      /** Mode for the selection, will be either SINGLE_TREE_SELECTION,
70       * CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION.
71       */
72      protected int                           selectionMode;
73  
74      /** Last path that was added. */
75      protected TreePath                        leadPath;
76      /** Index of the lead path in selection. */
77      protected int                           leadIndex;
78      /** Lead row. */
79      protected int                           leadRow;
80  
81      /** Used to make sure the paths are unique, will contain all the paths
82       * in <code>selection</code>.
83       */
84      private Hashtable                         uniquePaths;
85      private Hashtable                         lastPaths;
86      private TreePath  []                      tempPaths;
87  
88  
89      /**
90       * Creates a new instance of DefaultTreeSelectionModel that is
91       * empty, with a selection mode of DISCONTIGUOUS_TREE_SELECTION.
92       */
93      public DefaultTreeSelectionModel() {
94      listSelectionModel = new DefaultListSelectionModel  ();
95      selectionMode = DISCONTIGUOUS_TREE_SELECTION;
96      leadIndex = leadRow = -1;
97      uniquePaths = new Hashtable  ();
98      lastPaths = new Hashtable  ();
99      tempPaths = new TreePath  [1];
100     }
101 
102     /**
103      * Sets the RowMapper instance. This instance is used to determine
104      * the row for a particular TreePath.
105      */
106     public void setRowMapper(RowMapper   newMapper) {
107     rowMapper = newMapper;
108     resetRowSelection();
109     }
110 
111     /**
112      * Returns the RowMapper instance that is able to map a TreePath to a
113      * row.
114      */
115     public RowMapper   getRowMapper() {
116     return rowMapper;
117     }
118 
119     /**
120      * Sets the selection model, which must be one of SINGLE_TREE_SELECTION,
121      * CONTIGUOUS_TREE_SELECTION or DISCONTIGUOUS_TREE_SELECTION. If mode
122      * is not one of the defined value,
123      * <code>DISCONTIGUOUS_TREE_SELECTION</code> is assumed.
124      * <p>This may change the selection if the current selection is not valid
125      * for the new mode. For example, if three TreePaths are 
126      * selected when the mode is changed to <code>SINGLE_TREE_SELECTION</code>,
127      * only one TreePath will remain selected. It is up to the particular
128      * implementation to decide what TreePath remains selected.
129      * <p>
130      * Setting the mode to something other than the defined types will
131      * result in the mode becoming <code>DISCONTIGUOUS_TREE_SELECTION</code>.
132      */
133     public void setSelectionMode(int mode) {
134     int            oldMode = selectionMode;
135 
136     selectionMode = mode;
137     if(selectionMode != TreeSelectionModel.SINGLE_TREE_SELECTION &&
138        selectionMode != TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
139        selectionMode != TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION)
140         selectionMode = TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION;
141     if(oldMode != selectionMode && changeSupport != null)
142         changeSupport.firePropertyChange(SELECTION_MODE_PROPERTY,
143                          new Integer  (oldMode),
144                          new Integer  (selectionMode));
145     }
146 
147     /**
148      * Returns the selection mode, one of <code>SINGLE_TREE_SELECTION</code>,
149      * <code>DISCONTIGUOUS_TREE_SELECTION</code> or 
150      * <code>CONTIGUOUS_TREE_SELECTION</code>.
151      */
152     public int getSelectionMode() {
153     return selectionMode;
154     }
155 
156     /**
157       * Sets the selection to path. If this represents a change, then
158       * the TreeSelectionListeners are notified. If <code>path</code> is
159       * null, this has the same effect as invoking <code>clearSelection</code>.
160       *
161       * @param path new path to select
162       */
163     public void setSelectionPath(TreePath   path) {
164     if(path == null)
165         setSelectionPaths(null);
166     else {
167         TreePath  []          newPaths = new TreePath  [1];
168 
169         newPaths[0] = path;
170         setSelectionPaths(newPaths);
171     }
172     }
173 
174     /**
175       * Sets the selection to the paths in paths.  If this represents a
176       * change the TreeSelectionListeners are notified.  Potentially
177       * paths will be held by this object; in other words don't change
178       * any of the objects in the array once passed in.
179       * <p>If <code>paths</code> is
180       * null, this has the same effect as invoking <code>clearSelection</code>.
181       * <p>The lead path is set to the last path in <code>pPaths</code>.
182       * <p>If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>,
183       * and adding the new paths would make the selection discontiguous,
184       * the selection is reset to the first TreePath in <code>paths</code>.
185       *
186       * @param pPaths new selection
187       */
188     public void setSelectionPaths(TreePath  [] pPaths) {
189     int            newCount, newCounter, oldCount, oldCounter;
190     TreePath  []     paths = pPaths;
191 
192     if(paths == null)
193         newCount = 0;
194     else
195         newCount = paths.length;
196     if(selection == null)
197         oldCount = 0;
198     else
199         oldCount = selection.length;
200     if((newCount + oldCount) != 0) {
201         if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
202         /* If single selection and more than one path, only allow
203            first. */
204         if(newCount > 1) {
205             paths = new TreePath  [1];
206             paths[0] = pPaths[0];
207             newCount = 1;
208         }
209         }
210         else if(selectionMode ==
211             TreeSelectionModel.CONTIGUOUS_TREE_SELECTION) {
212         /* If contiguous selection and paths aren't contiguous,
213            only select the first path item. */
214         if(newCount > 0 && !arePathsContiguous(paths)) {
215             paths = new TreePath  [1];
216             paths[0] = pPaths[0];
217             newCount = 1;
218         }
219         }
220 
221         int              validCount = 0;
222         TreePath           beginLeadPath = leadPath;
223         Vector             cPaths = new Vector  (newCount + oldCount);
224 
225         lastPaths.clear();
226         leadPath = null;
227         /* Find the paths that are new. */
228         for(newCounter = 0; newCounter < newCount; newCounter++) {
229         if(paths[newCounter] != null &&
230            lastPaths.get(paths[newCounter]) == null) {
231             validCount++;
232             lastPaths.put(paths[newCounter], Boolean.TRUE);
233             if (uniquePaths.get(paths[newCounter]) == null) {
234             cPaths.addElement(new PathPlaceHolder
235                       (paths[newCounter], true));
236             }
237             leadPath = paths[newCounter];
238         }
239         }
240 
241         /* If the validCount isn't equal to newCount it means there
242            are some null in paths, remove them and set selection to
243            the new path. */
244         TreePath  []     newSelection;
245 
246         if(validCount == 0) {
247         newSelection = null;
248         }
249         else if (validCount != newCount) {
250         Enumeration   keys = lastPaths.keys();
251 
252         newSelection = new TreePath  [validCount];
253         validCount = 0;
254         while (keys.hasMoreElements()) {
255             newSelection[validCount++] = (TreePath  )keys.nextElement();
256         }
257         }
258         else {
259         newSelection = new TreePath  [paths.length];
260         System.arraycopy(paths, 0, newSelection, 0, paths.length);
261         }
262 
263         /* Get the paths that were selected but no longer selected. */
264         for(oldCounter = 0; oldCounter < oldCount; oldCounter++)
265         if(selection[oldCounter] != null && 
266             lastPaths.get(selection[oldCounter]) == null)
267             cPaths.addElement(new PathPlaceHolder
268                       (selection[oldCounter], false));
269 
270         selection = newSelection;
271 
272         Hashtable        tempHT = uniquePaths;
273 
274         uniquePaths = lastPaths;
275         lastPaths = tempHT;
276         lastPaths.clear();
277 
278         // No reason to do this now, but will still call it.
279         if(selection != null)
280         insureUniqueness();
281 
282         updateLeadIndex();
283 
284         resetRowSelection();
285         /* Notify of the change. */
286         if(cPaths.size() > 0)
287         notifyPathChange(cPaths, beginLeadPath);
288     }
289     }
290 
291     /**
292       * Adds path to the current selection. If path is not currently
293       * in the selection the TreeSelectionListeners are notified. This has
294       * no effect if <code>path</code> is null.
295       *
296       * @param path the new path to add to the current selection
297       */
298     public void addSelectionPath(TreePath   path) {
299     if(path != null) {
300         TreePath  []            toAdd = new TreePath  [1];
301 
302         toAdd[0] = path;
303         addSelectionPaths(toAdd);
304     }
305     }
306 
307     /**
308       * Adds paths to the current selection. If any of the paths in
309       * paths are not currently in the selection the TreeSelectionListeners
310       * are notified. This has
311       * no effect if <code>paths</code> is null.
312       * <p>The lead path is set to the last element in <code>paths</code>.
313       * <p>If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>,
314       * and adding the new paths would make the selection discontiguous.
315       * Then two things can result: if the TreePaths in <code>paths</code>
316       * are contiguous, then the selection becomes these TreePaths,
317       * otherwise the TreePaths aren't contiguous and the selection becomes
318       * the first TreePath in <code>paths</code>.
319       *
320       * @param paths the new path to add to the current selection
321       */
322     public void addSelectionPaths(TreePath  [] paths) {
323     int       newPathLength = ((paths == null) ? 0 : paths.length);
324 
325     if(newPathLength > 0) {
326         if(selectionMode == TreeSelectionModel.SINGLE_TREE_SELECTION) {
327         setSelectionPaths(paths);
328         }
329         else if(selectionMode == TreeSelectionModel.
330             CONTIGUOUS_TREE_SELECTION && !canPathsBeAdded(paths)) {
331         if(arePathsContiguous(paths)) {
332             setSelectionPaths(paths);
333         }
334         else {
335             TreePath  []          newPaths = new TreePath  [1];
336 
337             newPaths[0] = paths[0];
338             setSelectionPaths(newPaths);
339         }
340         }
341         else {
342         int               counter, validCount;
343         int               oldCount;
344         TreePath            beginLeadPath = leadPath;
345         Vector              cPaths = null;
346 
347         if(selection == null)
348             oldCount = 0;
349         else
350             oldCount = selection.length;
351         /* Determine the paths that aren't currently in the
352            selection. */
353         lastPaths.clear();
354         for(counter = 0, validCount = 0; counter < newPathLength;
355             counter++) {
356             if(paths[counter] != null) {
357             if (uniquePaths.get(paths[counter]) == null) {
358                 validCount++;
359                 if(cPaths == null)
360                 cPaths = new Vector  ();
361                 cPaths.addElement(new PathPlaceHolder
362                           (paths[counter], true));
363                 uniquePaths.put(paths[counter], Boolean.TRUE);
364                 lastPaths.put(paths[counter], Boolean.TRUE);
365             }
366             leadPath = paths[counter];
367             }
368         }
369 
370         if(leadPath == null) {
371             leadPath = beginLeadPath;
372         }
373 
374         if(validCount > 0) {
375             TreePath           newSelection[] = new TreePath  [oldCount +
376                                   validCount];
377 
378             /* And build the new selection. */
379             if(oldCount > 0) 
380             System.arraycopy(selection, 0, newSelection, 0,
381                      oldCount);
382             if(validCount != paths.length) {
383             /* Some of the paths in paths are already in
384                the selection. */
385             Enumeration     newPaths = lastPaths.keys();
386 
387             counter = oldCount;
388             while (newPaths.hasMoreElements()) {
389                 newSelection[counter++] = (TreePath  )newPaths.
390                                       nextElement();
391             }
392             }
393             else {
394             System.arraycopy(paths, 0, newSelection, oldCount,
395                      validCount);
396             }
397 
398             selection = newSelection;
399 
400             insureUniqueness();
401 
402             updateLeadIndex();
403 
404             resetRowSelection();
405 
406             notifyPathChange(cPaths, beginLeadPath);
407         }
408         else
409             leadPath = beginLeadPath;
410         lastPaths.clear();
411         }
412     }
413     }
414 
415     /**
416       * Removes path from the selection. If path is in the selection
417       * The TreeSelectionListeners are notified. This has no effect if
418       * <code>path</code> is null.
419       *
420       * @param path the path to remove from the selection
421       */
422     public void removeSelectionPath(TreePath   path) {
423     if(path != null) {
424         TreePath  []             rPath = new TreePath  [1];
425 
426         rPath[0] = path;
427         removeSelectionPaths(rPath);
428     }
429     }
430 
431     /**
432       * Removes paths from the selection.  If any of the paths in paths
433       * are in the selection the TreeSelectionListeners are notified.
434       * This has no effect if <code>paths</code> is null.
435       *
436       * @param paths the paths to remove from the selection
437       */
438     public void removeSelectionPaths(TreePath  [] paths) {
439     if (paths != null && selection != null && paths.length > 0) {
440         if(!canPathsBeRemoved(paths)) {
441         /* Could probably do something more interesting here! */
442         clearSelection();
443         }
444         else {
445         Vector        pathsToRemove = null;
446 
447         /* Find the paths that can be removed. */
448         for (int removeCounter = paths.length - 1; removeCounter >= 0;
449              removeCounter--) {
450             if(paths[removeCounter] != null) {
451             if (uniquePaths.get(paths[removeCounter]) != null) {
452                 if(pathsToRemove == null)
453                 pathsToRemove = new Vector  (paths.length);
454                 uniquePaths.remove(paths[removeCounter]);
455                 pathsToRemove.addElement(new PathPlaceHolder
456                      (paths[removeCounter], false));
457             }
458             }
459         }
460         if(pathsToRemove != null) {
461             int         removeCount = pathsToRemove.size();
462             TreePath      beginLeadPath = leadPath;
463 
464             if(removeCount == selection.length) {
465             selection = null;
466             }
467             else {
468             Enumeration            pEnum = uniquePaths.keys();
469             int                  validCount = 0;
470 
471             selection = new TreePath  [selection.length -
472                         removeCount];
473             while (pEnum.hasMoreElements()) {
474                 selection[validCount++] = (TreePath  )pEnum.
475                                           nextElement();
476             }
477             }
478             if (leadPath != null &&
479             uniquePaths.get(leadPath) == null) {
480             if (selection != null) {
481                 leadPath = selection[selection.length - 1];
482             }
483             else {
484                 leadPath = null;
485             }
486             }
487             else if (selection != null) {
488             leadPath = selection[selection.length - 1];
489             }
490             else {
491             leadPath = null;
492             }
493             updateLeadIndex();
494 
495             resetRowSelection();
496 
497             notifyPathChange(pathsToRemove, beginLeadPath);
498         }
499         }
500     }
501     }
502 
503     /**
504       * Returns the first path in the selection. This is useful if there
505       * if only one item currently selected.
506       */
507     public TreePath   getSelectionPath() {
508     if(selection != null)
509         return selection[0];
510     return null;
511     }
512 
513     /**
514       * Returns the paths in the selection. This will return null (or an
515       * empty array) if nothing is currently selected.
516       */
517     public TreePath  [] getSelectionPaths() {
518     if(selection != null) {
519         int                 pathSize = selection.length;
520         TreePath  []          result = new TreePath  [pathSize];
521 
522         System.arraycopy(selection, 0, result, 0, pathSize);
523         return result;
524     }
525     return null;
526     }
527 
528     /**
529      * Returns the number of paths that are selected.
530      */
531     public int getSelectionCount() {
532     return (selection == null) ? 0 : selection.length;
533     }
534 
535     /**
536       * Returns true if the path, <code>path</code>,
537       * is in the current selection.
538       */
539     public boolean isPathSelected(TreePath   path) {
540     return (path != null) ? (uniquePaths.get(path) != null) : false;
541     }
542 
543     /**
544       * Returns true if the selection is currently empty.
545       */
546     public boolean isSelectionEmpty() {
547     return (selection == null);
548     }
549 
550     /**
551       * Empties the current selection.  If this represents a change in the
552       * current selection, the selection listeners are notified.
553       */
554     public void clearSelection() {
555     if(selection != null) {
556         int                    selSize = selection.length;
557         boolean[]              newness = new boolean[selSize];
558 
559         for(int counter = 0; counter < selSize; counter++)
560         newness[counter] = false;
561 
562         TreeSelectionEvent     event = new TreeSelectionEvent
563         (this, selection, newness, leadPath, null);
564 
565         leadPath = null;
566         leadIndex = leadRow = -1;
567         uniquePaths.clear();
568         selection = null;
569         resetRowSelection();
570         fireValueChanged(event);
571     }
572     }
573 
574     /**
575       * Adds x to the list of listeners that are notified each time the
576       * set of selected TreePaths changes.
577       *
578       * @param x the new listener to be added
579       */
580     public void addTreeSelectionListener(TreeSelectionListener x) {
581     listenerList.add(TreeSelectionListener.class, x);
582     }
583 
584     /**
585       * Removes x from the list of listeners that are notified each time
586       * the set of selected TreePaths changes.
587       *
588       * @param x the listener to remove
589       */
590     public void removeTreeSelectionListener(TreeSelectionListener x) {
591     listenerList.remove(TreeSelectionListener.class, x);
592     }
593 
594     /**
595      * Returns an array of all the tree selection listeners 
596      * registered on this model.
597      *
598      * @return all of this model's <code>TreeSelectionListener</code>s 
599      *         or an empty
600      *         array if no tree selection listeners are currently registered
601      *
602      * @see #addTreeSelectionListener
603      * @see #removeTreeSelectionListener
604      *
605      * @since 1.4
606      */
607     public TreeSelectionListener[] getTreeSelectionListeners() {
608         return (TreeSelectionListener[])listenerList.getListeners(
609                 TreeSelectionListener.class);
610     }
611 
612     /**
613      * Notifies all listeners that are registered for
614      * tree selection events on this object.  
615      * @see #addTreeSelectionListener
616      * @see EventListenerList
617      */
618     protected void fireValueChanged(TreeSelectionEvent e) {
619     // Guaranteed to return a non-null array
620     Object  [] listeners = listenerList.getListenerList();
621     // TreeSelectionEvent e = null;
622     // Process the listeners last to first, notifying
623     // those that are interested in this event
624     for (int i = listeners.length-2; i>=0; i-=2) {
625         if (listeners[i]==TreeSelectionListener.class) {
626         // Lazily create the event:
627         // if (e == null)
628         // e = new ListSelectionEvent(this, firstIndex, lastIndex);
629         ((TreeSelectionListener)listeners[i+1]).valueChanged(e);
630         }          
631     }
632     }
633 
634     /**
635      * Returns an array of all the objects currently registered
636      * as <code><em>Foo</em>Listener</code>s
637      * upon this model.
638      * <code><em>Foo</em>Listener</code>s are registered using the
639      * <code>add<em>Foo</em>Listener</code> method.
640      *
641      * <p>
642      *
643      * You can specify the <code>listenerType</code> argument
644      * with a class literal,
645      * such as
646      * <code><em>Foo</em>Listener.class</code>.
647      * For example, you can query a
648      * <code>DefaultTreeSelectionModel</code> <code>m</code>
649      * for its tree selection listeners with the following code:
650      *
651      * <pre>TreeSelectionListener[] tsls = (TreeSelectionListener[])(m.getListeners(TreeSelectionListener.class));</pre>
652      *
653      * If no such listeners exist, this method returns an empty array.
654      *
655      * @param listenerType the type of listeners requested; this parameter
656      *          should specify an interface that descends from
657      *          <code>java.util.EventListener</code>
658      * @return an array of all objects registered as
659      *          <code><em>Foo</em>Listener</code>s on this component,
660      *          or an empty array if no such
661      *          listeners have been added
662      * @exception ClassCastException if <code>listenerType</code>
663      *          doesn't specify a class or interface that implements
664      *          <code>java.util.EventListener</code>
665      *
666      * @see #getTreeSelectionListeners
667      * @see #getPropertyChangeListeners
668      *
669      * @since 1.3
670      */
671     public <T extends EventListener  > T[] getListeners(Class  <T> listenerType) { 
672     return listenerList.getListeners(listenerType); 
673     }
674 
675     /**
676       * Returns all of the currently selected rows. This will return
677       * null (or an empty array) if there are no selected TreePaths or
678       * a RowMapper has not been set.
679       * This may return an array of length less that than of the selected
680       * TreePaths if some of the rows are not visible (that is the
681       * RowMapper returned -1 for the row corresponding to the TreePath).
682       */
683     public int[] getSelectionRows() {
684     // This is currently rather expensive.  Needs
685     // to be better support from ListSelectionModel to speed this up.
686     if(rowMapper != null && selection != null) {
687         int[]      rows = rowMapper.getRowsForPaths(selection);
688 
689         if (rows != null) {
690         int       invisCount = 0;
691 
692         for (int counter = rows.length - 1; counter >= 0; counter--) {
693             if (rows[counter] == -1) {
694             invisCount++;
695             }
696         }
697         if (invisCount > 0) {
698             if (invisCount == rows.length) {
699             rows = null;
700             }
701             else {
702             int[]    tempRows = new int[rows.length - invisCount];
703 
704             for (int counter = rows.length - 1, visCounter = 0;
705                  counter >= 0; counter--) {
706                 if (rows[counter] != -1) {
707                 tempRows[visCounter++] = rows[counter];
708                 }
709             }
710             rows = tempRows;
711             }
712         }
713         }
714         return rows;
715     }
716     return null;
717     }
718 
719     /**
720      * Returns the smallest value obtained from the RowMapper for the
721      * current set of selected TreePaths. If nothing is selected,
722      * or there is no RowMapper, this will return -1.
723       */
724     public int getMinSelectionRow() {
725     return listSelectionModel.getMinSelectionIndex();
726     }
727 
728     /**
729      * Returns the largest value obtained from the RowMapper for the
730      * current set of selected TreePaths. If nothing is selected,
731      * or there is no RowMapper, this will return -1.
732       */
733     public int getMaxSelectionRow() {
734     return listSelectionModel.getMaxSelectionIndex();
735     }
736 
737     /**
738       * Returns true if the row identified by <code>row</code> is selected.
739       */
740     public boolean isRowSelected(int row) {
741     return listSelectionModel.isSelectedIndex(row);
742     }
743 
744     /**
745      * Updates this object's mapping from TreePath to rows. This should
746      * be invoked when the mapping from TreePaths to integers has changed
747      * (for example, a node has been expanded).
748      * <p>You do not normally have to call this, JTree and its associated
749      * Listeners will invoke this for you. If you are implementing your own
750      * View class, then you will have to invoke this.
751      * <p>This will invoke <code>insureRowContinuity</code> to make sure
752      * the currently selected TreePaths are still valid based on the
753      * selection mode.
754      */
755     public void resetRowSelection() {
756     listSelectionModel.clearSelection();
757     if(selection != null && rowMapper != null) {
758         int               aRow;
759         int               validCount = 0;
760         int[]             rows = rowMapper.getRowsForPaths(selection);
761 
762         for(int counter = 0, maxCounter = selection.length;
763         counter < maxCounter; counter++) {
764         aRow = rows[counter];
765         if(aRow != -1) {
766             listSelectionModel.addSelectionInterval(aRow, aRow);
767         }
768         }
769         if(leadIndex != -1 && rows != null) {
770         leadRow = rows[leadIndex];
771         }
772         else if (leadPath != null) {
773         // Lead selection path doesn't have to be in the selection.
774         tempPaths[0] = leadPath;
775         rows = rowMapper.getRowsForPaths(tempPaths);
776         leadRow = (rows != null) ? rows[0] : -1;
777         }
778         else {
779         leadRow = -1;
780         }
781         insureRowContinuity();
782 
783     }
784     else
785         leadRow = -1;
786     }
787 
788     /**
789      * Returns the lead selection index. That is the last index that was
790      * added.
791      */
792     public int getLeadSelectionRow() {
793     return leadRow;
794     }
795 
796     /**
797      * Returns the last path that was added. This may differ from the 
798      * leadSelectionPath property maintained by the JTree.
799      */
800     public TreePath   getLeadSelectionPath() {
801     return leadPath;
802     }
803 
804     /**
805      * Adds a PropertyChangeListener to the listener list.
806      * The listener is registered for all properties.
807      * <p>
808      * A PropertyChangeEvent will get fired when the selection mode
809      * changes.
810      *
811      * @param listener  the PropertyChangeListener to be added
812      */
813     public synchronized void addPropertyChangeListener(
814                                 PropertyChangeListener   listener) {
815         if (changeSupport == null) {
816             changeSupport = new SwingPropertyChangeSupport(this);
817         }
818         changeSupport.addPropertyChangeListener(listener);
819     }
820 
821     /**
822      * Removes a PropertyChangeListener from the listener list.
823      * This removes a PropertyChangeListener that was registered
824      * for all properties.
825      *
826      * @param listener  the PropertyChangeListener to be removed
827      */
828 
829     public synchronized void removePropertyChangeListener(
830                                 PropertyChangeListener   listener) {
831         if (changeSupport == null) {
832             return;
833         }
834         changeSupport.removePropertyChangeListener(listener);
835     }
836 
837     /**
838      * Returns an array of all the property change listeners 
839      * registered on this <code>DefaultTreeSelectionModel</code>.
840      *
841      * @return all of this model's <code>PropertyChangeListener</code>s 
842      *         or an empty
843      *         array if no property change listeners are currently registered
844      *
845      * @see #addPropertyChangeListener
846      * @see #removePropertyChangeListener
847      *
848      * @since 1.4
849      */
850     public PropertyChangeListener  [] getPropertyChangeListeners() {
851         if (changeSupport == null) {
852             return new PropertyChangeListener  [0];
853         }
854         return changeSupport.getPropertyChangeListeners();
855     }
856 
857     /**
858      * Makes sure the currently selected <code>TreePath</code>s are valid
859      * for the current selection mode.
860      * If the selection mode is <code>CONTIGUOUS_TREE_SELECTION</code>
861      * and a <code>RowMapper</code> exists, this will make sure all
862      * the rows are contiguous, that is, when sorted all the rows are
863      * in order with no gaps.
864      * If the selection isn't contiguous, the selection is
865      * reset to contain the first set, when sorted, of contiguous rows.
866      * <p>
867      * If the selection mode is <code>SINGLE_TREE_SELECTION</code> and
868      * more than one TreePath is selected, the selection is reset to
869      * contain the first path currently selected.
870      */
871     protected void insureRowContinuity() {
872     if(selectionMode == TreeSelectionModel.CONTIGUOUS_TREE_SELECTION &&
873        selection != null && rowMapper != null) {
874         DefaultListSelectionModel   lModel = listSelectionModel;
875         int                       min = lModel.getMinSelectionIndex();
876 
877         if(min != -1) {
878         for(int counter = min,
879             maxCounter = lModel.getMaxSelectionIndex();
880                 counter <= maxCounter; counter++) {
881             if(!lModel.isSelectedIndex(counter)) {
882             if(counter == min) {
883                 clearSelection();
884             }
885             else {
886                 TreePath  [] newSel = new TreePath  [counter - min];
887                 int selectionIndex[] = rowMapper.getRowsForPaths(selection);
888                 // find the actual selection pathes corresponded to the
889                 // rows of the new selection
890                 for (int i = 0; i < selectionIndex.length; i++) {
891                 if (selectionIndex[i]<counter) {
892                     newSel[selectionIndex[i]-min] = selection[i];
893                 }
894                 }
895                 setSelectionPaths(newSel);
896                 break;
897            &n