int setMin, int setMax, boolean clearFirst) {        for(int i = Math.min(setMin, clearMin); i <= Math.max(setMax, clearMax); i++) {            boolean shouldClear = contains(clearMin, clearMax, i);            boolean shouldSet = contains(setMin, setMax, i);            if (shouldSet && shouldClear) {                if (clearFirst) {                    shouldClear = false;                }                else {                    shouldSet = false;                }            }            if (shouldSet) {                set(i);            }            if (shouldClear) {                clear(i);            }        }        fireValueChanged();    }   /*   Change the selection with the effect of first clearing the values    *   in the inclusive range [clearMin, clearMax] then setting the values    *   in the inclusive range [setMin, setMax]. Do this in one pass so    *   that no values are cleared if they would later be set.    */    private void changeSelection(int clearMin, int clearMax, int setMin, int setMax) {        changeSelection(clearMin, clearMax, setMin, setMax, true);    }    public void clearSelection() {	removeSelectionInterval(minIndex, maxIndex);    }    public void setSelectionInterval(int index0, int index1) {        if (index0 == -1 || index1 == -1) {            return;        }        if (getSelectionMode() == SINGLE_SELECTION) {            index0 = index1;        }        updateLeadAnchorIndices(index0, index1);        int clearMin = minIndex;        int clearMax = maxIndex;	int setMin = Math.min(index0, index1);	int setMax = Math.max(index0, index1);        changeSelection(clearMin, clearMax, setMin, setMax);    }    public void addSelectionInterval(int index0, int index1)    {        if (index0 == -1 || index1 == -1) {            return;        }        if (getSelectionMode() != MULTIPLE_INTERVAL_SELECTION) {            setSelectionInterval(index0, index1);            return;        }        updateLeadAnchorIndices(index0, index1);        int clearMin = MAX;        int clearMax = MIN;	int setMin = Math.min(index0, index1);	int setMax = Math.max(index0, index1);        changeSelection(clearMin, clearMax, setMin, setMax);    }    public void removeSelectionInterval(int index0, int index1)    {        if (index0 == -1 || index1 == -1) {            return;        }        updateLeadAnchorIndices(index0, index1);	int clearMin = Math.min(index0, index1);	int clearMax = Math.max(index0, index1);	int setMin = MAX;	int setMax = MIN;        changeSelection(clearMin, clearMax, setMin, setMax);    }    private void setState(int index, boolean state) {        if (state) {	    set(index); 	}	else {	    clear(index); 	}    }    /**     * Insert length indices beginning before/after index. If the value      * at index is itself selected, set all of the newly inserted      * items, otherwise leave them unselected. This method is typically     * called to sync the selection model with a corresponding change     * in the data model.     */    public void insertIndexInterval(int index, int length, boolean before)    {	/* The first new index will appear at insMinIndex and the last	 * one will appear at insMaxIndex	 */	int insMinIndex = (before) ? index : index + 1;	int insMaxIndex = (insMinIndex + length) - 1;	/* Right shift the entire bitset by length, beginning with	 * index-1 if before is true, index+1 if it's false (i.e. with	 * insMinIndex).	 */	for(int i = maxIndex; i >= insMinIndex; i--) {	    setState(i + length, value.get(i)); 	}	/* Initialize the newly inserted indices.	 */       	boolean setInsertedValues = value.get(index); 	for(int i = insMinIndex; i <= insMaxIndex; i++) { 	    setState(i, setInsertedValues); 	}    }    /**     * Remove the indices in the interval index0,index1 (inclusive) from     * the selection model.  This is typically called to sync the selection     * model width a corresponding change in the data model.  Note     * that (as always) index0 can be greater than index1.     */    public void removeIndexInterval(int index0, int index1)    {	int rmMinIndex = Math.min(index0, index1);	int rmMaxIndex = Math.max(index0, index1);	int gapLength = (rmMaxIndex - rmMinIndex) + 1;	/* Shift the entire bitset to the left to close the index0, index1	 * gap.	 */	for(int i = rmMinIndex; i <= maxIndex; i++) {	    setState(i, value.get(i + gapLength)); 	}    }    public void setValueIsAdjusting(boolean isAdjusting) {	if (isAdjusting != this.isAdjusting) {	    this.isAdjusting = isAdjusting;	    this.fireValueChanged(isAdjusting);	}    }    public String toString() {	String s =  ((getValueIsAdjusting()) ? "~" : "=") + value.toString();	return getClass().getName() + " " + Integer.toString(hashCode()) + " " + s;    }    /**     * Returns a clone of the receiver with the same selection.     * <code>listenerLists</code> are not duplicated.     *     * @return a clone of the receiver     * @exception CloneNotSupportedException if the receiver does not     *    both (a) implement the <code>Cloneable</code> interface     *    and (b) define a <code>clone</code> method     */    public Object clone() throws CloneNotSupportedException {	OptionListModel clone = (OptionListModel)super.clone();	clone.value = (BitSet)value.clone();	clone.listenerList = new EventListenerList();	return clone;    }    public int getAnchorSelectionIndex() {        return anchorIndex;    }    public int getLeadSelectionIndex() {        return leadIndex;    }    /**     * Set the anchor selection index, leaving all selection values unchanged.      *     * @see #getAnchorSelectionIndex          * @see #setLeadSelectionIndex     */       public void setAnchorSelectionIndex(int anchorIndex) {        this.anchorIndex = anchorIndex;    }    /**     * Set the lead selection index, ensuring that values between the      * anchor and the new lead are either all selected or all deselected.      * If the value at the anchor index is selected, first clear all the      * values in the range [anchor, oldLeadIndex], then select all the values      * values in the range [anchor, newLeadIndex], where oldLeadIndex is the old      * leadIndex and newLeadIndex is the new one.      * <p>      * If the value at the anchor index is not selected, do the same thing in reverse,      * selecting values in the old range and deslecting values in the new one.      * <p>     * Generate a single event for this change and notify all listeners.      * For the purposes of generating minimal bounds in this event, do the      * operation in a single pass; that way the first and last index inside the      * ListSelectionEvent that is broadcast will refer to cells that actually      * changed value because of this method. If, instead, this operation were      * done in two steps the effect on the selection state would be the same      * but two events would be generated and the bounds around the changed values      * would be wider, including cells that had been first cleared and only      * to later be set.      * <p>     * This method can be used in the mouseDragged() method of a UI class      * to extend a selection.       *     * @see #getLeadSelectionIndex          * @see #setAnchorSelectionIndex     */       public void setLeadSelectionIndex(int leadIndex) {        int anchorIndex = this.anchorIndex;        if (getSelectionMode() == SINGLE_SELECTION) {            anchorIndex = leadIndex;        }        int oldMin = Math.min(this.anchorIndex, this.leadIndex);;        int oldMax = Math.max(this.anchorIndex, this.leadIndex);;	int newMin = Math.min(anchorIndex, leadIndex);	int newMax = Math.max(anchorIndex, leadIndex);        if (value.get(this.anchorIndex)) {            changeSelection(oldMin, oldMax, newMin, newMax);        }        else {            changeSelection(newMin, newMax, oldMin, oldMax, false);        }        this.anchorIndex = anchorIndex;        this.leadIndex = leadIndex;    }    /**     * This method is responsible for storing the state     * of the initial selection.  If the selectionMode     * is the default, i.e allowing only for SINGLE_SELECTION,     * then the very last OPTION that has the selected     * attribute set wins.     */    public void setInitialSelection(int i) {	if (initialValue.get(i)) {	    return;	}	if (selectionMode == SINGLE_SELECTION) {	    // reset to empty	    initialValue.and(new BitSet());	}	initialValue.set(i);    }    /**     * Fetches the BitSet that represents the initial     * set of selected items in the list.     */    public BitSet getInitialSelection() {	return initialValue;    }}