* A JSlider component has the following properties:
*
| Property | Stored in | Bound? |
|---|---|---|
| extent | model | no |
| inverted | slider | yes |
| labelTable | slider | yes |
| majorTickSpacing | slider | yes |
| maximum | model | yes |
| minimum | model | yes |
| minorTickSpacing | slider | yes |
| model | slider | yes |
| orientation | slider | yes |
| paintLabels | slider | yes |
| paintTicks | slider | yes |
| snapToTicks | slider | yes |
| value | model | no |
| valueIsAdjusting | model | no |
* The various behavioural aspects of these properties follows: *
* *JSlider
* component.
*/
protected class AccessibleJSlider extends JComponent.AccessibleJComponent
implements AccessibleValue
{
private static final long serialVersionUID = -6301740148041106789L;
/**
* Creates a new AccessibleJSlider instance.
*/
protected AccessibleJSlider()
{
// Nothing to do here.
}
/**
* Returns a set containing the current state of the {@link JSlider}
* component.
*
* @return The accessible state set.
*/
public AccessibleStateSet getAccessibleStateSet()
{
AccessibleStateSet result = super.getAccessibleStateSet();
if (orientation == JSlider.HORIZONTAL)
result.add(AccessibleState.HORIZONTAL);
else if (orientation == JSlider.VERTICAL)
result.add(AccessibleState.VERTICAL);
return result;
}
/**
* Returns the accessible role for the JSlider component.
*
* @return {@link AccessibleRole#SLIDER}.
*/
public AccessibleRole getAccessibleRole()
{
return AccessibleRole.SLIDER;
}
/**
* Returns an object that provides access to the current, minimum and
* maximum values for the {@link JSlider}. Since this class implements
* {@link AccessibleValue}, it returns itself.
*
* @return The accessible value.
*/
public AccessibleValue getAccessibleValue()
{
return this;
}
/**
* Returns the current value of the {@link JSlider} component, as an
* {@link Integer}.
*
* @return The current value of the {@link JSlider} component.
*/
public Number getCurrentAccessibleValue()
{
return new Integer(getValue());
}
/**
* Sets the current value of the {@link JSlider} component and sends a
* {@link PropertyChangeEvent} (with the property name
* {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
* listeners. If the supplied value is null, this method
* does nothing and returns false.
*
* @param value the new slider value (null permitted).
*
* @return true if the slider value is updated, and
* false otherwise.
*/
public boolean setCurrentAccessibleValue(Number value)
{
if (value == null)
return false;
Number oldValue = getCurrentAccessibleValue();
setValue(value.intValue());
firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue,
new Integer(getValue()));
return true;
}
/**
* Returns the minimum value of the {@link JSlider} component, as an
* {@link Integer}.
*
* @return The minimum value of the {@link JSlider} component.
*/
public Number getMinimumAccessibleValue()
{
return new Integer(getMinimum());
}
/**
* Returns the maximum value of the {@link JSlider} component, as an
* {@link Integer}.
*
* @return The maximum value of the {@link JSlider} component.
*/
public Number getMaximumAccessibleValue()
{
return new Integer(getMaximum());
}
}
/** Whether or not this slider paints its ticks. */
private transient boolean paintTicks;
/** Whether or not this slider paints its track. */
private transient boolean paintTrack = true;
/** Whether or not this slider paints its labels. */
private transient boolean paintLabels;
/**
* A dictionary of (Integer, Component) pairs where each Component is a
* JLabel and the Integer determines where the label will be painted.
*/
private transient Dictionary labelTable;
/** The model used to store the slider's range and current value. */
protected BoundedRangeModel sliderModel;
/** The space/distance between major ticks. */
protected int majorTickSpacing;
/** The space/distance between minor ticks. */
protected int minorTickSpacing;
/** Whether the slider snaps its values to ticks. */
protected boolean snapToTicks;
/** The orientation (horizontal or vertical) of the slider. */
protected int orientation = HORIZONTAL;
/** Whether the slider is inverted. */
private transient boolean isInverted;
/**
* The listener that monitors the slider's model and forwards events to the
* slider's listeners (see createChangeListener()).
*/
protected ChangeListener changeListener;
/** The change event that is passed to all listeners of this slider. */
protected transient ChangeEvent changeEvent;
/**
* Creates a new horizontal JSlider instance with a minimum of
* 0, a maximum of 100, and a value of 50.
*/
public JSlider()
{
this(HORIZONTAL, 0, 100, 50);
}
/**
* Creates a new JSlider instance with the given orientation
* and a minimum of 0, a maximum of 100, and a value of 50.
*
* @param orientation The orientation of the slider ({@link #HORIZONTAL} or
* {@link #VERTICAL}).
*
* @throws IllegalArgumentException if orientation is not one of
* the specified values.
*/
public JSlider(int orientation)
{
this(orientation, 0, 100, 50);
}
/**
* Creates a new horizontal JSlider instance with the given
* maximum and minimum and a value that is halfway between the minimum and the
* maximum.
*
* @param minimum The minimum value.
* @param maximum The maximum value.
*
* @throws IllegalArgumentException if minimum is greater than
* maximum.
*/
public JSlider(int minimum, int maximum)
{
this(HORIZONTAL, minimum, maximum, (maximum + minimum) / 2);
}
/**
* Creates a new horizontal JSlider instance with the given
* minimum, maximum, and value.
*
* @param minimum The minimum value.
* @param maximum The maximum value.
* @param value The initial value.
*
* @throws IllegalArgumentException if value is not in the
* specified range.
* @throws IllegalArgumentException if minimum is greater than
* maximum.
*/
public JSlider(int minimum, int maximum, int value)
{
this(HORIZONTAL, minimum, maximum, value);
}
/**
* Creates a new JSlider instance with the given orientation,
* minimum, maximum, and value.
*
* @param orientation The orientation of the slider ({@link #HORIZONTAL} or
* {@link #VERTICAL}).
* @param minimum The minimum value of the JSlider.
* @param maximum The maximum value of the JSlider.
* @param value The initial value of the JSlider.
*
* @throws IllegalArgumentException if orientation is not one of
* the specified values.
* @throws IllegalArgumentException if value is not in the
* specified range.
* @throws IllegalArgumentException if minimum is greater than
* maximum.
*/
public JSlider(int orientation, int minimum, int maximum, int value)
{
sliderModel = new DefaultBoundedRangeModel(value, 0, minimum, maximum);
if (orientation != HORIZONTAL && orientation != VERTICAL)
throw new IllegalArgumentException(orientation
+ " is not a legal orientation");
this.orientation = orientation;
changeListener = createChangeListener();
sliderModel.addChangeListener(changeListener);
updateUI();
}
/**
* Creates a new horizontal JSlider instance with the given
* model.
*
* @param model The model (null not permitted).
*
* @throws NullPointerException if model is null.
*/
public JSlider(BoundedRangeModel model)
{
sliderModel = model;
changeListener = createChangeListener();
sliderModel.addChangeListener(changeListener);
updateUI();
}
/**
* Returns the slider's value (from the slider's model).
*
* @return The value of the slider.
*
* @see #setValue(int)
*/
public int getValue()
{
return sliderModel.getValue();
}
/**
* Sets the slider's value and sends a {@link ChangeEvent} to all
* registered listeners. Note that the model will fire a change event to all
* of its registered listeners first (with the model as the event source) and
* then the slider will fire another change event to all of its registered
* listeners (this time with the slider as the event source).
*
* @param value the new value.
*
* @see #getValue()
*/
public void setValue(int value)
{
sliderModel.setValue(value);
}
/**
* Returns the slider's UI delegate.
*
* @return The slider's UI delegate.
*/
public SliderUI getUI()
{
return (SliderUI) ui;
}
/**
* Sets the slider's UI delegate.
*
* @param ui the UI delegate.
*/
public void setUI(SliderUI ui)
{
super.setUI(ui);
}
/**
* Sets this slider's UI delegate to the default (obtained from the
* {@link UIManager}) for the current look and feel.
*/
public void updateUI()
{
updateLabelUIs();
setUI((SliderUI) UIManager.getUI(this));
}
/**
* Returns the suffix ("SliderUI" in this case) used to
* determine the class name for a UI delegate that can provide the look and
* feel for a JSlider.
*
* @return "SliderUI".
*/
public String getUIClassID()
{
return "SliderUI";
}
/**
* Creates a {@link ChangeListener} that is added to the slider's model and
* forwards change events generated by the model to the listeners that are
* registered with the JSlider (by calling the
* {@link #fireStateChanged} method).
*
* @return A new listener.
*/
protected ChangeListener createChangeListener()
{
return new ChangeListener()
{
public void stateChanged(ChangeEvent ce)
{
// No need to trigger a repaint since the UI listens to the model
// as well. All we need to do is pass on the stateChanged event
// to our listeners.
fireStateChanged();
}
};
}
/**
* Registers a listener with the slider so that it will receive
* {@link ChangeEvent} notifications. Note that change events generated
* by the slider's model will be forwarded automatically to the slider's
* listeners.
*
* @param listener the listener to register.
*
* @see #removeChangeListener(ChangeListener)
*/
public void addChangeListener(ChangeListener listener)
{
listenerList.add(ChangeListener.class, listener);
}
/**
* Removes a listener from this slider so that it will no longer receive
* {@link ChangeEvent} notifications from the slider.
*
* @param listener The listener to remove.
*
* @see #addChangeListener(ChangeListener)
*/
public void removeChangeListener(ChangeListener listener)
{
listenerList.remove(ChangeListener.class, listener);
}
/**
* Sends a {@link ChangeEvent} to all registered listeners, with this slider
* as the source.
*/
protected void fireStateChanged()
{
Object[] changeListeners = listenerList.getListenerList();
if (changeEvent == null)
changeEvent = new ChangeEvent(this);
for (int i = changeListeners.length - 2; i >= 0; i -= 2)
{
if (changeListeners[i] == ChangeListener.class)
((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
}
}
/**
* Returns an array containing all the {@link ChangeListener} instances
* registered with this slider. If no listeners are registered, this method
* returns an empty array.
*
* @return An array array containing all the {@link ChangeListener} instances
* registered with this slider (possibly empty, but never
* null).
*/
public ChangeListener[] getChangeListeners()
{
return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
}
/**
* Returns the slider's model, which stores the minimum, maximum and current
* values.
*
* @return The slider's model.
*
* @see #setModel(BoundedRangeModel)
*/
public BoundedRangeModel getModel()
{
return sliderModel;
}
/**
* Sets the slider's model and sends a {@link PropertyChangeEvent} (with the
* property name "model") to all registered listeners. The change listener
* that the slider registered with the original model is removed and added
* to the new model (this ensures that {@link ChangeEvent} notifications
* generated by the model are automatically forwarded to listeners that are
* registered with the slider).
*
* @param model The model to use with the slider.
*
* @see #getModel()
*/
public void setModel(BoundedRangeModel model)
{
// I didn't do the null pointer check on purpose.
// If you try it with Sun's, it'll go ahead and set it to null
// and bork the next time it tries to access the model.
if (model != sliderModel)
{
BoundedRangeModel oldModel = sliderModel;
sliderModel = model;
oldModel.removeChangeListener(changeListener);
sliderModel.addChangeListener(changeListener);
firePropertyChange("model", oldModel, sliderModel);
}
}
/**
* Returns the minimum value of the slider (from the slider's model).
*
* @return The minimum value of the slider.
*
* @see #setMinimum(int)
*/
public int getMinimum()
{
return sliderModel.getMinimum();
}
/**
* Sets the minimum value of the slider and fires a
* {@link PropertyChangeEvent} (with the property name "minimum") to all
* registered listeners. Note that:
* *
*
valueIsAdjusting flag from the slider's model.
*
* @return The valueIsAdjusting flag from the slider's model.
*
* @see #setValueIsAdjusting(boolean)
*/
public boolean getValueIsAdjusting()
{
return sliderModel.getValueIsAdjusting();
}
/**
* Sets the valueIsAdjusting flag in the slider's model, and
* sends a {@link ChangeEvent} to all registered listeners.
*
* @param adjusting the new flag value.
*
* @see #getValueIsAdjusting()
*/
public void setValueIsAdjusting(boolean adjusting)
{
sliderModel.setValueIsAdjusting(adjusting);
}
/**
* Returns the slider's extent value, obtained from the slider's model.
*
* @return The extent value.
*
* @see #setExtent(int)
*/
public int getExtent()
{
return sliderModel.getExtent();
}
/**
* Sets the slider's extent value and sends a {@link ChangeEvent} to all
* registered listeners. Note that the model will fire a change event to all
* of its registered listeners first (with the model as the event source) and
* then the slider will fire another change event to all of its registered
* listeners (this time with the slider as the event source).
*
* @param extent The extent value for this slider.
*
* @see #getExtent()
*/
public void setExtent(int extent)
{
sliderModel.setExtent(extent);
}
/**
* Returns the orientation of the slider, either {@link JSlider#HORIZONTAL}
* or {@link JSlider#VERTICAL}.
*
* @return The orientation of the slider.
*
* @see #setOrientation(int)
*/
public int getOrientation()
{
return orientation;
}
/**
* Sets the orientation for the slider and sends a
* {@link PropertyChangeEvent} (with the property name "orientation") to all
* registered listeners.
*
* @param orientation the orientation (one of {@link JSlider#HORIZONTAL} or
* {@link JSlider#VERTICAL}).
*
* @throws IllegalArgumentException if orientation is not one of
* the permitted values.
*
* @see #getOrientation()
*/
public void setOrientation(int orientation)
{
if (orientation != VERTICAL && orientation != HORIZONTAL)
throw new IllegalArgumentException(
"orientation must be one of: VERTICAL, HORIZONTAL");
if (orientation != this.orientation)
{
int oldOrientation = this.orientation;
this.orientation = orientation;
firePropertyChange("orientation", oldOrientation, this.orientation);
revalidate();
}
}
/**
* Returns the label table for the slider.
*
* @return The label table for the slider (possibly null).
*
* @see #setLabelTable(Dictionary)
*/
public Dictionary getLabelTable()
{
return labelTable;
}
/**
* Sets the table of labels for the slider and sends a
* {@link PropertyChangeEvent} (with the property name "labelTable") to all
* registered listeners.
*
* @param table the table of labels (null permitted).
*
* @see #getLabelTable()
*/
public void setLabelTable(Dictionary table)
{
if (table != labelTable)
{
Dictionary oldTable = labelTable;
labelTable = table;
updateLabelUIs();
firePropertyChange("labelTable", oldTable, labelTable);
revalidate();
repaint();
}
}
/**
* Resets the UI delegates for the labels in the labelTable to
* the default for the current look and feel.
*/
protected void updateLabelUIs()
{
if (labelTable != null)
{
for (Enumeration list = labelTable.elements(); list.hasMoreElements();)
{
Object o = list.nextElement();
if (o instanceof JComponent)
{
JComponent jc = (JComponent) o;
jc.updateUI();
jc.setSize(jc.getPreferredSize());
}
}
}
}
/**
* Creates a hashtable of (Integer, JLabel) pairs that can be
* used as a label table for this slider. The labels will start from the
* slider's minimum and increase by the increment. Each label will have a text
* string indicating its integer value.
*
* @param increment The increment between labels (must be > 0).
*
* @return A hashtable containing the labels.
*
* @throws IllegalArgumentException if increment is not greater
* than zero.
*/
public Hashtable createStandardLabels(int increment)
{
return createStandardLabels(increment, sliderModel.getMinimum());
}
/**
* Creates a hashtable of (Integer, JLabel) pairs that can be
* used as a label table for this slider. The labels will start from the
* given start value and increase by the increment. Each label will have a
* text string indicating its integer value.
*
* @param increment The increment between labels (must be > 0).
* @param start The value to start from.
*
* @return A hashtable with the labels and their keys.
*
* @throws IllegalArgumentException if increment is not greater
* than zero, or start is not within the range of the
* model.
*/
public Hashtable createStandardLabels(int increment, int start)
{
if (increment <= 0)
throw new IllegalArgumentException("Requires 'increment' > 0.");
if (start < getMinimum() || start > getMaximum())
throw new IllegalArgumentException("The 'start' value is out of range.");
Hashtable table = new Hashtable();
int max = getMaximum();
for (int i = start; i <= max; i += increment)
{
LabelUIResource label = new LabelUIResource(String.valueOf(i),
JLabel.CENTER);
table.put(new Integer(i), label);
}
return table;
}
/**
* Returns the flag that controls whether or not the value scale for the
* slider is inverted (the default value is false).
*
* @return The flag that controls whether or not the value scale for the
* slider is inverted.
*
* @see #setInverted(boolean)
*/
public boolean getInverted()
{
return isInverted;
}
/**
* Sets the flag that controls whether or not the value scale for the
* slider is inverted and, if the new flag value is different to the old flag
* value, sends a {@link PropertyChangeEvent} to all registered listeners.
* Typically, a horizontal slider will display a scale that increases from
* left to right, but this is reversed if the 'inverted' flag is set to
* true. Similarly, a vertical slider will display a scale that
* increases from bottom to top, and this is reversed if the 'inverted' flag
* is set to true.
*
* @param inverted the new flag value.
*
* @see #getInverted()
*/
public void setInverted(boolean inverted)
{
if (isInverted != inverted)
{
boolean oldInverted = isInverted;
isInverted = inverted;
firePropertyChange("inverted", oldInverted, isInverted);
repaint();
}
}
/**
* Returns the distance between major tick marks along the slider's value
* scale.
*
* @return The amount of units between each major tick mark.
*
* @see #setMajorTickSpacing(int)
*/
public int getMajorTickSpacing()
{
return majorTickSpacing;
}
/**
* Sets the distance between major tick marks along the slider's value scale,
* and sends a {@link PropertyChangeEvent} (with the property name
* "majorTickSpacing") to all registered listeners.
*
* @param spacing the distance between major tick marks.
*
* @see #getMajorTickSpacing()
*/
public void setMajorTickSpacing(int spacing)
{
if (majorTickSpacing != spacing)
{
int oldSpacing = majorTickSpacing;
majorTickSpacing = spacing;
if (labelTable == null && majorTickSpacing > 0 && getPaintLabels())
setLabelTable(createStandardLabels(majorTickSpacing));
firePropertyChange("majorTickSpacing", oldSpacing, majorTickSpacing);
if (getPaintTicks())
repaint();
}
}
/**
* Returns the distance between minor tick marks along the slider's value
* scale.
*
* @return The distance between minor tick marks along the slider's value
* scale.
*
* @see #setMinorTickSpacing(int)
*/
public int getMinorTickSpacing()
{
return minorTickSpacing;
}
/**
* Sets the distance between minor tick marks along the slider's value scale,
* and sends a {@link PropertyChangeEvent} (with the property name
* "minorTickSpacing") to all registered listeners.
*
* @param spacing the distance between minor tick marks.
*
* @see #getMinorTickSpacing()
*/
public void setMinorTickSpacing(int spacing)
{
if (minorTickSpacing != spacing)
{
int oldSpacing = minorTickSpacing;
minorTickSpacing = spacing;
firePropertyChange("minorTickSpacing", oldSpacing, minorTickSpacing);
if (getPaintTicks())
repaint();
}
}
/**
* Returns the flag that controls whether the slider thumb will snap to ticks.
* Sliders that snap to ticks will automatically move the thumb to the
* nearest tick mark.
*
* @return true if the slider thumb automatically.
*
* @see #setSnapToTicks(boolean)
*/
public boolean getSnapToTicks()
{
return snapToTicks;
}
/**
* Sets the flag that controls whether the slider thumb will snap to ticks
* and sends a {@link PropertyChangeEvent} (with the property name
* 'snapToTicks') to all registered listeners. Sliders that snap to ticks
* will automatically move the thumb to the nearest tick mark.
*
* @param snap the new flag value.
*
* @see #getSnapToTicks()
*/
public void setSnapToTicks(boolean snap)
{
if (snap != snapToTicks)
{
snapToTicks = snap;
firePropertyChange("snapToTicks", !snap, snap);
}
}
/**
* Returns the flag that controls whether or not tick marks are painted along
* the slider's value scale.
*
* @return true if tick marks should be painted, and
* false if tick marks should not be painted.
*
* @see #setPaintTicks(boolean)
*/
public boolean getPaintTicks()
{
return paintTicks;
}
/**
* Sets the flag that controls whether or not tick marks are painted along
* the slider's value scale, and sends a {@link PropertyChangeEvent} (with
* the property name "paintTicks") to all registered listeners. In
* addition to setting this property to true, one or both of the
* minor tick spacing and major tick spacing attributes must be set to a
* value greater than 0 in order for ticks to be painted.
*
* @param paint Whether ticks will be painted.
*
* @see #getPaintTicks()
*/
public void setPaintTicks(boolean paint)
{
if (paint != paintTicks)
{
boolean oldPaintTicks = paintTicks;
paintTicks = paint;
firePropertyChange("paintTicks", oldPaintTicks, paintTicks);
revalidate();
repaint();
}
}
/**
* Returns the flag that controls whether or not the track is painted.
*
* @return Whether the track will be painted.
*
* @see #setPaintTrack(boolean)
*/
public boolean getPaintTrack()
{
return paintTrack;
}
/**
* Sets the flag that controls whether or not the track is painted, and
* sends a {@link PropertyChangeEvent} (for the "paintTrack" property) to all
* registered listeners.
*
* @param paint Whether the track will be painted.
*
* @see #getPaintTrack()
*/
public void setPaintTrack(boolean paint)
{
if (paintTrack != paint)
{
paintTrack = paint;
firePropertyChange("paintTrack", !paint, paint);
repaint();
}
}
/**
* Returns the flag that controls whether or not labels are painted for the
* tick marks along the slider.
*
* @return Whether labels will be painted.
*
* @see #setPaintLabels(boolean)
*/
public boolean getPaintLabels()
{
return paintLabels;
}
/**
* Sets the flag that controls whether or not labels are painted for the
* tick marks along the slider and sends a {@link PropertyChangeEvent} (with
* the property name "paintLabels") to all registered listeners.
*
* @param paint Whether labels will be painted.
*
* @see #getPaintLabels()
*/
public void setPaintLabels(boolean paint)
{
if (paint != paintLabels)
{
paintLabels = paint;
if (paint && majorTickSpacing > 0 && labelTable == null)
setLabelTable(createStandardLabels(majorTickSpacing));
firePropertyChange("paintLabels", !paint, paint);
revalidate();
repaint();
}
}
/**
* Returns an implementation-dependent string describing the attributes of
* this JSlider.
*
* @return A string describing the attributes of this JSlider
* (never null).
*/
protected String paramString()
{
String superParamStr = super.paramString();
CPStringBuilder sb = new CPStringBuilder();
sb.append(",isInverted=").append(getInverted());
sb.append(",majorTickSpacing=").append(getMajorTickSpacing());
sb.append(",minorTickSpacing=").append(getMinorTickSpacing());
sb.append(",orientation=");
if (orientation == HORIZONTAL)
sb.append("HORIZONTAL");
else
sb.append("VERTICAL");
sb.append(",paintLabels=").append(getPaintLabels());
sb.append(",paintTicks=").append(getPaintTicks());
sb.append(",paintTrack=").append(getPaintTrack());
sb.append(",snapToTicks=").append(getSnapToTicks());
// the following is output by the reference implementation. We don't
// strictly need to replicate this. Perhaps it has some meaning, but
// I couldn't determine it yet...
sb.append(",snapToValue=true");
return superParamStr + sb.toString();
}
/**
* Returns the object that provides accessibility features for this
* JSlider component.
*
* @return The accessible context (an instance of {@link AccessibleJSlider}).
*/
public AccessibleContext getAccessibleContext()
{
if (accessibleContext == null)
accessibleContext = new AccessibleJSlider();
return accessibleContext;
}
}