optionlistmodel.java

Mobile 应用程序使用 Java Micro Edition (Java ME) 平台

                                 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;
    }
}