001    /* JSlider.java --
002       Copyright (C) 2002, 2004, 2005, 2006,  Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    
039    package javax.swing;
040    
041    import gnu.java.lang.CPStringBuilder;
042    
043    import java.awt.MenuContainer;
044    import java.awt.image.ImageObserver;
045    import java.beans.PropertyChangeEvent;
046    import java.io.Serializable;
047    import java.util.Dictionary;
048    import java.util.Enumeration;
049    import java.util.Hashtable;
050    
051    import javax.accessibility.Accessible;
052    import javax.accessibility.AccessibleContext;
053    import javax.accessibility.AccessibleRole;
054    import javax.accessibility.AccessibleState;
055    import javax.accessibility.AccessibleStateSet;
056    import javax.accessibility.AccessibleValue;
057    import javax.swing.event.ChangeEvent;
058    import javax.swing.event.ChangeListener;
059    import javax.swing.plaf.SliderUI;
060    import javax.swing.plaf.UIResource;
061    
062    /**
063     * A visual component that allows selection of a value within a
064     * range by adjusting a thumb in a track. The values for the minimum,
065     * maximum, extent and value are stored in a {@link
066     * DefaultBoundedRangeModel}.
067     * <p>
068     * A <code>JSlider</code> component has the following properties:
069     * </p>
070     *
071     * <table>
072     * <tr><th> Property         </th><th> Stored in </th><th> Bound? </th></tr>
073     * <tr><td> extent           </td><td> model     </td><td> no     </td></tr>
074     * <tr><td> inverted         </td><td> slider    </td><td> yes    </td></tr>
075     * <tr><td> labelTable       </td><td> slider    </td><td> yes    </td></tr>
076     * <tr><td> majorTickSpacing </td><td> slider    </td><td> yes    </td></tr>
077     * <tr><td> maximum          </td><td> model     </td><td> yes     </td></tr>
078     * <tr><td> minimum          </td><td> model     </td><td> yes     </td></tr>
079     * <tr><td> minorTickSpacing </td><td> slider    </td><td> yes    </td></tr>
080     * <tr><td> model            </td><td> slider    </td><td> yes    </td></tr>
081     * <tr><td> orientation      </td><td> slider    </td><td> yes    </td></tr>
082     * <tr><td> paintLabels      </td><td> slider    </td><td> yes    </td></tr>
083     * <tr><td> paintTicks       </td><td> slider    </td><td> yes    </td></tr>
084     * <tr><td> snapToTicks      </td><td> slider    </td><td> yes     </td></tr>
085     * <tr><td> value            </td><td> model     </td><td> no     </td></tr>
086     * <tr><td> valueIsAdjusting </td><td> model     </td><td> no     </td></tr>
087     * </table>
088     *
089     * <p>
090     * The various behavioural aspects of these properties follows:
091     * </p>
092     *
093     * <ul>
094     * <li>
095     * When a non-bound property stored in the slider changes, the slider fires
096     * a {@link ChangeEvent} to its change listeners.
097     * </li>
098     * <li>
099     * When a bound property stored in the slider changes, the slider fires a
100     * {@link PropertyChangeEvent} to its property change listeners.
101     * </li>
102     * <li>
103     * If any of the model's properties change, it fires a {@link ChangeEvent} to
104     * its listeners, which include the slider.
105     * </li>
106     * <li>
107     * If the slider receives a {@link ChangeEvent} from its model, it will
108     * propagate the event to its own change listeners, with the event's "source"
109     * property set to refer to the slider, rather than the model.
110     * </li>
111     * </ul>
112     */
113    public class JSlider extends JComponent implements SwingConstants, Accessible,
114                                                       ImageObserver,
115                                                       MenuContainer, Serializable
116    {
117    
118      /**
119       * A little testing shows that the reference implementation creates
120       * labels from a class named LabelUIResource.
121       */
122      private class LabelUIResource
123        extends JLabel
124        implements UIResource
125      {
126        LabelUIResource(String text, int align)
127        {
128          super(text, align);
129          setName("Slider.label");
130        }
131      }
132    
133      private static final long serialVersionUID = -1441275936141218479L;
134    
135      /**
136       * Provides the accessibility features for the <code>JSlider</code>
137       * component.
138       */
139      protected class AccessibleJSlider extends JComponent.AccessibleJComponent
140        implements AccessibleValue
141      {
142        private static final long serialVersionUID = -6301740148041106789L;
143    
144        /**
145         * Creates a new <code>AccessibleJSlider</code> instance.
146         */
147        protected AccessibleJSlider()
148        {
149          // Nothing to do here.
150        }
151    
152        /**
153         * Returns a set containing the current state of the {@link JSlider}
154         * component.
155         *
156         * @return The accessible state set.
157         */
158        public AccessibleStateSet getAccessibleStateSet()
159        {
160          AccessibleStateSet result = super.getAccessibleStateSet();
161          if (orientation == JSlider.HORIZONTAL)
162            result.add(AccessibleState.HORIZONTAL);
163          else if (orientation == JSlider.VERTICAL)
164            result.add(AccessibleState.VERTICAL);
165          return result;
166        }
167    
168        /**
169         * Returns the accessible role for the <code>JSlider</code> component.
170         *
171         * @return {@link AccessibleRole#SLIDER}.
172         */
173        public AccessibleRole getAccessibleRole()
174        {
175          return AccessibleRole.SLIDER;
176        }
177    
178        /**
179         * Returns an object that provides access to the current, minimum and
180         * maximum values for the {@link JSlider}.  Since this class implements
181         * {@link AccessibleValue}, it returns itself.
182         *
183         * @return The accessible value.
184         */
185        public AccessibleValue getAccessibleValue()
186        {
187          return this;
188        }
189    
190        /**
191         * Returns the current value of the {@link JSlider} component, as an
192         * {@link Integer}.
193         *
194         * @return The current value of the {@link JSlider} component.
195         */
196        public Number getCurrentAccessibleValue()
197        {
198          return new Integer(getValue());
199        }
200    
201        /**
202         * Sets the current value of the {@link JSlider} component and sends a
203         * {@link PropertyChangeEvent} (with the property name
204         * {@link AccessibleContext#ACCESSIBLE_VALUE_PROPERTY}) to all registered
205         * listeners.  If the supplied value is <code>null</code>, this method
206         * does nothing and returns <code>false</code>.
207         *
208         * @param value  the new slider value (<code>null</code> permitted).
209         *
210         * @return <code>true</code> if the slider value is updated, and
211         *     <code>false</code> otherwise.
212         */
213        public boolean setCurrentAccessibleValue(Number value)
214        {
215          if (value == null)
216            return false;
217          Number oldValue = getCurrentAccessibleValue();
218          setValue(value.intValue());
219          firePropertyChange(AccessibleContext.ACCESSIBLE_VALUE_PROPERTY, oldValue,
220                             new Integer(getValue()));
221          return true;
222        }
223    
224        /**
225         * Returns the minimum value of the {@link JSlider} component, as an
226         * {@link Integer}.
227         *
228         * @return The minimum value of the {@link JSlider} component.
229         */
230        public Number getMinimumAccessibleValue()
231        {
232          return new Integer(getMinimum());
233        }
234    
235        /**
236         * Returns the maximum value of the {@link JSlider} component, as an
237         * {@link Integer}.
238         *
239         * @return The maximum value of the {@link JSlider} component.
240         */
241        public Number getMaximumAccessibleValue()
242        {
243          return new Integer(getMaximum());
244        }
245      }
246    
247      /** Whether or not this slider paints its ticks. */
248      private transient boolean paintTicks;
249    
250      /** Whether or not this slider paints its track. */
251      private transient boolean paintTrack = true;
252    
253      /** Whether or not this slider paints its labels. */
254      private transient boolean paintLabels;
255    
256      /**
257       * A dictionary of (Integer, Component) pairs where each Component is a
258       * JLabel and the Integer determines where the label will be painted.
259       */
260      private transient Dictionary labelTable;
261    
262      /** The model used to store the slider's range and current value. */
263      protected BoundedRangeModel sliderModel;
264    
265      /** The space/distance between major ticks. */
266      protected int majorTickSpacing;
267    
268      /** The space/distance between minor ticks. */
269      protected int minorTickSpacing;
270    
271      /** Whether the slider snaps its values to ticks. */
272      protected boolean snapToTicks;
273    
274      /** The orientation (horizontal or vertical) of the slider. */
275      protected int orientation = HORIZONTAL;
276    
277      /** Whether the slider is inverted. */
278      private transient boolean isInverted;
279    
280      /**
281       * The listener that monitors the slider's model and forwards events to the
282       * slider's listeners (see <code>createChangeListener()</code>).
283       */
284      protected ChangeListener changeListener;
285    
286      /** The change event that is passed to all listeners of this slider. */
287      protected transient ChangeEvent changeEvent;
288    
289      /**
290       * Creates a new horizontal <code>JSlider</code> instance with a minimum of
291       * 0, a maximum of 100, and a value of 50.
292       */
293      public JSlider()
294      {
295        this(HORIZONTAL, 0, 100, 50);
296      }
297    
298      /**
299       * Creates a new <code>JSlider</code> instance with the given orientation
300       * and a minimum of 0, a maximum of 100, and a value of 50.
301       *
302       * @param orientation The orientation of the slider ({@link #HORIZONTAL} or
303       *                    {@link #VERTICAL}).
304       *
305       * @throws IllegalArgumentException if <code>orientation</code> is not one of
306       *         the specified values.
307       */
308      public JSlider(int orientation)
309      {
310        this(orientation, 0, 100, 50);
311      }
312    
313      /**
314       * Creates a new horizontal <code>JSlider</code> instance with the given
315       * maximum and minimum and a value that is halfway between the minimum and the
316       * maximum.
317       *
318       * @param minimum The minimum value.
319       * @param maximum The maximum value.
320       *
321       * @throws IllegalArgumentException if <code>minimum</code> is greater than
322       *     <code>maximum</code>.
323       */
324      public JSlider(int minimum, int maximum)
325      {
326        this(HORIZONTAL, minimum, maximum, (maximum + minimum) / 2);
327      }
328    
329      /**
330       * Creates a new horizontal <code>JSlider</code> instance with the given
331       * minimum, maximum, and value.
332       *
333       * @param minimum The minimum value.
334       * @param maximum The maximum value.
335       * @param value The initial value.
336       *
337       * @throws IllegalArgumentException if <code>value</code> is not in the
338       *     specified range.
339       * @throws IllegalArgumentException if <code>minimum</code> is greater than
340       *     <code>maximum</code>.
341       */
342      public JSlider(int minimum, int maximum, int value)
343      {
344        this(HORIZONTAL, minimum, maximum, value);
345      }
346    
347      /**
348       * Creates a new <code>JSlider</code> instance with the given orientation,
349       * minimum, maximum, and value.
350       *
351       * @param orientation The orientation of the slider ({@link #HORIZONTAL} or
352       *                    {@link #VERTICAL}).
353       * @param minimum The minimum value of the JSlider.
354       * @param maximum The maximum value of the JSlider.
355       * @param value The initial value of the JSlider.
356       *
357       * @throws IllegalArgumentException if <code>orientation</code> is not one of
358       *     the specified values.
359       * @throws IllegalArgumentException if <code>value</code> is not in the
360       *     specified range.
361       * @throws IllegalArgumentException if <code>minimum</code> is greater than
362       *     <code>maximum</code>.
363       */
364      public JSlider(int orientation, int minimum, int maximum, int value)
365      {
366        sliderModel = new DefaultBoundedRangeModel(value, 0, minimum, maximum);
367        if (orientation != HORIZONTAL && orientation != VERTICAL)
368          throw new IllegalArgumentException(orientation
369                                             + " is not a legal orientation");
370        this.orientation = orientation;
371        changeListener = createChangeListener();
372        sliderModel.addChangeListener(changeListener);
373        updateUI();
374      }
375    
376      /**
377       * Creates a new horizontal <code>JSlider</code> instance with the given
378       * model.
379       *
380       * @param model The model (<code>null</code> not permitted).
381       *
382       * @throws NullPointerException if <code>model</code> is <code>null</code>.
383       */
384      public JSlider(BoundedRangeModel model)
385      {
386        sliderModel = model;
387        changeListener = createChangeListener();
388        sliderModel.addChangeListener(changeListener);
389        updateUI();
390      }
391    
392      /**
393       * Returns the slider's value (from the slider's model).
394       *
395       * @return The value of the slider.
396       *
397       * @see #setValue(int)
398       */
399      public int getValue()
400      {
401        return sliderModel.getValue();
402      }
403    
404      /**
405       * Sets the slider's value and sends a {@link ChangeEvent} to all
406       * registered listeners.  Note that the model will fire a change event to all
407       * of its registered listeners first (with the model as the event source) and
408       * then the slider will fire another change event to all of its registered
409       * listeners (this time with the slider as the event source).
410       *
411       * @param value  the new value.
412       *
413       * @see #getValue()
414       */
415      public void setValue(int value)
416      {
417        sliderModel.setValue(value);
418      }
419    
420      /**
421       * Returns the slider's UI delegate.
422       *
423       * @return The slider's UI delegate.
424       */
425      public SliderUI getUI()
426      {
427        return (SliderUI) ui;
428      }
429    
430      /**
431       * Sets the slider's UI delegate.
432       *
433       * @param ui  the UI delegate.
434       */
435      public void setUI(SliderUI ui)
436      {
437        super.setUI(ui);
438      }
439    
440      /**
441       * Sets this slider's UI delegate to the default (obtained from the
442       * {@link UIManager}) for the current look and feel.
443       */
444      public void updateUI()
445      {
446        updateLabelUIs();
447        setUI((SliderUI) UIManager.getUI(this));
448      }
449    
450      /**
451       * Returns the suffix (<code>"SliderUI"</code> in this case) used to
452       * determine the class name for a UI delegate that can provide the look and
453       * feel for a <code>JSlider</code>.
454       *
455       * @return <code>"SliderUI"</code>.
456       */
457      public String getUIClassID()
458      {
459        return "SliderUI";
460      }
461    
462      /**
463       * Creates a {@link ChangeListener} that is added to the slider's model and
464       * forwards change events generated by the model to the listeners that are
465       * registered with the <code>JSlider</code> (by calling the
466       * {@link #fireStateChanged} method).
467       *
468       * @return A new listener.
469       */
470      protected ChangeListener createChangeListener()
471      {
472        return new ChangeListener()
473          {
474            public void stateChanged(ChangeEvent ce)
475            {
476              // No need to trigger a repaint since the UI listens to the model
477              // as well. All we need to do is pass on the stateChanged event
478              // to our listeners.
479              fireStateChanged();
480            }
481          };
482      }
483    
484      /**
485       * Registers a listener with the slider so that it will receive
486       * {@link ChangeEvent} notifications.  Note that change events generated
487       * by the slider's model will be forwarded automatically to the slider's
488       * listeners.
489       *
490       * @param listener  the listener to register.
491       *
492       * @see #removeChangeListener(ChangeListener)
493       */
494      public void addChangeListener(ChangeListener listener)
495      {
496        listenerList.add(ChangeListener.class, listener);
497      }
498    
499      /**
500       * Removes a listener from this slider so that it will no longer receive
501       * {@link ChangeEvent} notifications from the slider.
502       *
503       * @param listener The listener to remove.
504       *
505       * @see #addChangeListener(ChangeListener)
506       */
507      public void removeChangeListener(ChangeListener listener)
508      {
509        listenerList.remove(ChangeListener.class, listener);
510      }
511    
512      /**
513       * Sends a {@link ChangeEvent} to all registered listeners, with this slider
514       * as the source.
515       */
516      protected void fireStateChanged()
517      {
518        Object[] changeListeners = listenerList.getListenerList();
519        if (changeEvent == null)
520          changeEvent = new ChangeEvent(this);
521        for (int i = changeListeners.length - 2; i >= 0; i -= 2)
522          {
523            if (changeListeners[i] == ChangeListener.class)
524              ((ChangeListener) changeListeners[i + 1]).stateChanged(changeEvent);
525          }
526      }
527    
528      /**
529       * Returns an array containing all the {@link ChangeListener} instances
530       * registered with this slider.  If no listeners are registered, this method
531       * returns an empty array.
532       *
533       * @return An array array containing all the {@link ChangeListener} instances
534       *     registered with this slider (possibly empty, but never
535       *     <code>null</code>).
536       */
537      public ChangeListener[] getChangeListeners()
538      {
539        return (ChangeListener[]) listenerList.getListeners(ChangeListener.class);
540      }
541    
542      /**
543       * Returns the slider's model, which stores the minimum, maximum and current
544       * values.
545       *
546       * @return The slider's model.
547       *
548       * @see #setModel(BoundedRangeModel)
549       */
550      public BoundedRangeModel getModel()
551      {
552        return sliderModel;
553      }
554    
555      /**
556       * Sets the slider's model and sends a {@link PropertyChangeEvent} (with the
557       * property name "model") to all registered listeners.   The change listener
558       * that the slider registered with the original model is removed and added
559       * to the new model (this ensures that {@link ChangeEvent} notifications
560       * generated by the model are automatically forwarded to listeners that are
561       * registered with the slider).
562       *
563       * @param model The model to use with the slider.
564       *
565       * @see #getModel()
566       */
567      public void setModel(BoundedRangeModel model)
568      {
569        // I didn't do the null pointer check on purpose.
570        // If you try it with Sun's, it'll go ahead and set it to null
571        // and bork the next time it tries to access the model.
572        if (model != sliderModel)
573          {
574            BoundedRangeModel oldModel = sliderModel;
575            sliderModel = model;
576            oldModel.removeChangeListener(changeListener);
577            sliderModel.addChangeListener(changeListener);
578            firePropertyChange("model", oldModel, sliderModel);
579          }
580      }
581    
582      /**
583       * Returns the minimum value of the slider (from the slider's model).
584       *
585       * @return The minimum value of the slider.
586       *
587       * @see #setMinimum(int)
588       */
589      public int getMinimum()
590      {
591        return sliderModel.getMinimum();
592      }
593    
594      /**
595       * Sets the minimum value of the slider and fires a
596       * {@link PropertyChangeEvent} (with the property name "minimum") to all
597       * registered listeners.  Note that:
598       * <p>
599       * <ul>
600       * <li>the minimum value is stored in the slider's model (see
601       *     {@link #getModel()});</li>
602       * <li>in addition to the property change event, the slider also fires a
603       *     {@link ChangeEvent}.</li>
604       * </ul>
605       *
606       * @param minimum The minimum value of the slider.
607       *
608       * @see #getMinimum()
609       */
610      public void setMinimum(int minimum)
611      {
612        int old = sliderModel.getMinimum();
613        sliderModel.setMinimum(minimum);
614        if (minimum != old)
615          firePropertyChange("minimum", old, minimum);
616      }
617    
618      /**
619       * Returns the slider's maximum value (obtained from the slider's model).
620       *
621       * @return The maximum value of the slider.
622       *
623       * @see #setMaximum(int)
624       */
625      public int getMaximum()
626      {
627        return sliderModel.getMaximum();
628      }
629    
630      /**
631       * Sets the maximum value of the slider and fires a
632       * {@link PropertyChangeEvent} (with the property name "maximum") to all
633       * registered listeners.  Note that:
634       * <p>
635       * <ul>
636       * <li>the maximum value is stored in the slider's model (see
637       *     {@link #getModel()});</li>
638       * <li>in addition to the property change event, the slider also fires a
639       *     {@link ChangeEvent}.</li>
640       * </ul>
641       *
642       * @param maximum The maximum value of the slider.
643       *
644       * @see #getMaximum()
645       */
646      public void setMaximum(int maximum)
647      {
648        int old = sliderModel.getMaximum();
649        sliderModel.setMaximum(maximum);
650        if (maximum != old)
651          firePropertyChange("maximum", old, maximum);
652      }
653    
654      /**
655       * Returns the <code>valueIsAdjusting</code> flag from the slider's model.
656       *
657       * @return The <code>valueIsAdjusting</code> flag from the slider's model.
658       *
659       * @see #setValueIsAdjusting(boolean)
660       */
661      public boolean getValueIsAdjusting()
662      {
663        return sliderModel.getValueIsAdjusting();
664      }
665    
666      /**
667       * Sets the <code>valueIsAdjusting</code> flag in the slider's model, and
668       * sends a {@link ChangeEvent} to all registered listeners.
669       *
670       * @param adjusting  the new flag value.
671       *
672       * @see #getValueIsAdjusting()
673       */
674      public void setValueIsAdjusting(boolean adjusting)
675      {
676        sliderModel.setValueIsAdjusting(adjusting);
677      }
678    
679      /**
680       * Returns the slider's extent value, obtained from the slider's model.
681       *
682       * @return The extent value.
683       *
684       * @see #setExtent(int)
685       */
686      public int getExtent()
687      {
688        return sliderModel.getExtent();
689      }
690    
691      /**
692       * Sets the slider's extent value and sends a {@link ChangeEvent} to all
693       * registered listeners.  Note that the model will fire a change event to all
694       * of its registered listeners first (with the model as the event source) and
695       * then the slider will fire another change event to all of its registered
696       * listeners (this time with the slider as the event source).
697       *
698       * @param extent The extent value for this slider.
699       *
700       * @see #getExtent()
701       */
702      public void setExtent(int extent)
703      {
704        sliderModel.setExtent(extent);
705      }
706    
707      /**
708       * Returns the orientation of the slider, either {@link JSlider#HORIZONTAL}
709       * or {@link JSlider#VERTICAL}.
710       *
711       * @return The orientation of the slider.
712       *
713       * @see #setOrientation(int)
714       */
715      public int getOrientation()
716      {
717        return orientation;
718      }
719    
720      /**
721       * Sets the orientation for the slider and sends a
722       * {@link PropertyChangeEvent} (with the property name "orientation") to all
723       * registered listeners.
724       *
725       * @param orientation  the orientation (one of {@link JSlider#HORIZONTAL} or
726       *     {@link JSlider#VERTICAL}).
727       *
728       * @throws IllegalArgumentException if <code>orientation</code> is not one of
729       *     the permitted values.
730       *
731       * @see #getOrientation()
732       */
733      public void setOrientation(int orientation)
734      {
735        if (orientation != VERTICAL && orientation != HORIZONTAL)
736          throw new IllegalArgumentException(
737              "orientation must be one of: VERTICAL, HORIZONTAL");
738        if (orientation != this.orientation)
739          {
740            int oldOrientation = this.orientation;
741            this.orientation = orientation;
742            firePropertyChange("orientation", oldOrientation, this.orientation);
743            revalidate();
744          }
745      }
746    
747      /**
748       * Returns the label table for the slider.
749       *
750       * @return The label table for the slider (possibly <code>null</code>).
751       *
752       * @see #setLabelTable(Dictionary)
753       */
754      public Dictionary getLabelTable()
755      {
756        return labelTable;
757      }
758    
759      /**
760       * Sets the table of labels for the slider and sends a
761       * {@link PropertyChangeEvent} (with the property name "labelTable") to all
762       * registered listeners.
763       *
764       * @param table  the table of labels (<code>null</code> permitted).
765       *
766       * @see #getLabelTable()
767       */
768      public void setLabelTable(Dictionary table)
769      {
770        if (table != labelTable)
771          {
772            Dictionary oldTable = labelTable;
773            labelTable = table;
774            updateLabelUIs();
775            firePropertyChange("labelTable", oldTable, labelTable);
776            revalidate();
777            repaint();
778          }
779      }
780    
781      /**
782       * Resets the UI delegates for the labels in the <code>labelTable</code> to
783       * the default for the current look and feel.
784       */
785      protected void updateLabelUIs()
786      {
787        if (labelTable != null)
788          {
789            for (Enumeration list = labelTable.elements(); list.hasMoreElements();)
790              {
791                Object o = list.nextElement();
792                if (o instanceof JComponent)
793                  {
794                    JComponent jc = (JComponent) o;
795                    jc.updateUI();
796                    jc.setSize(jc.getPreferredSize());
797                  }
798              }
799          }
800      }
801    
802      /**
803       * Creates a hashtable of <code>(Integer, JLabel)</code> pairs that can be
804       * used as a label table for this slider. The labels will start from the
805       * slider's minimum and increase by the increment. Each label will have a text
806       * string indicating its integer value.
807       *
808       * @param increment The increment between labels (must be > 0).
809       *
810       * @return A hashtable containing the labels.
811       *
812       * @throws IllegalArgumentException if <code>increment</code> is not greater
813       *         than zero.
814       */
815      public Hashtable createStandardLabels(int increment)
816      {
817        return createStandardLabels(increment, sliderModel.getMinimum());
818      }
819    
820      /**
821       * Creates a hashtable of <code>(Integer, JLabel)</code> pairs that can be
822       * used as a label table for this slider. The labels will start from the
823       * given start value and increase by the increment. Each  label will have a
824       * text string indicating its integer value.
825       *
826       * @param increment The increment between labels (must be > 0).
827       * @param start The value to start from.
828       *
829       * @return A hashtable with the labels and their keys.
830       *
831       * @throws IllegalArgumentException if <code>increment</code> is not greater
832       *         than zero, or <code>start</code> is not within the range of the
833       *         model.
834       */
835      public Hashtable createStandardLabels(int increment, int start)
836      {
837        if (increment <= 0)
838          throw new IllegalArgumentException("Requires 'increment' > 0.");
839        if (start < getMinimum() || start > getMaximum())
840          throw new IllegalArgumentException("The 'start' value is out of range.");
841        Hashtable table = new Hashtable();
842        int max = getMaximum();
843        for (int i = start; i <= max; i += increment)
844          {
845            LabelUIResource label = new LabelUIResource(String.valueOf(i),
846                                                        JLabel.CENTER);
847            table.put(new Integer(i), label);
848          }
849        return table;
850      }
851    
852      /**
853       * Returns the flag that controls whether or not the value scale for the
854       * slider is inverted (the default value is <code>false</code>).
855       *
856       * @return The flag that controls whether or not the value scale for the
857       *     slider is inverted.
858       *
859       * @see #setInverted(boolean)
860       */
861      public boolean getInverted()
862      {
863        return isInverted;
864      }
865    
866      /**
867       * Sets the flag that controls whether or not the value scale for the
868       * slider is inverted and, if the new flag value is different to the old flag
869       * value, sends a {@link PropertyChangeEvent} to all registered listeners.
870       * Typically, a horizontal slider will display a scale that increases from
871       * left to right, but this is reversed if the 'inverted' flag is set to
872       * <code>true</code>.  Similarly, a vertical slider will display a scale that
873       * increases from bottom to top, and this is reversed if the 'inverted' flag
874       * is set to <code>true</code>.
875       *
876       * @param inverted  the new flag value.
877       *
878       * @see #getInverted()
879       */
880      public void setInverted(boolean inverted)
881      {
882        if (isInverted != inverted)
883          {
884            boolean oldInverted = isInverted;
885            isInverted = inverted;
886            firePropertyChange("inverted", oldInverted, isInverted);
887            repaint();
888          }
889      }
890    
891      /**
892       * Returns the distance between major tick marks along the slider's value
893       * scale.
894       *
895       * @return The amount of units between each major tick mark.
896       *
897       * @see #setMajorTickSpacing(int)
898       */
899      public int getMajorTickSpacing()
900      {
901        return majorTickSpacing;
902      }
903    
904      /**
905       * Sets the distance between major tick marks along the slider's value scale,
906       * and sends a {@link PropertyChangeEvent} (with the property name
907       * "majorTickSpacing") to all registered listeners.
908       *
909       * @param spacing  the distance between major tick marks.
910       *
911       * @see #getMajorTickSpacing()
912       */
913      public void setMajorTickSpacing(int spacing)
914      {
915        if (majorTickSpacing != spacing)
916          {
917            int oldSpacing = majorTickSpacing;
918            majorTickSpacing = spacing;
919            if (labelTable == null && majorTickSpacing > 0 && getPaintLabels())
920              setLabelTable(createStandardLabels(majorTickSpacing));
921            firePropertyChange("majorTickSpacing", oldSpacing, majorTickSpacing);
922            if (getPaintTicks())
923              repaint();
924          }
925      }
926    
927      /**
928       * Returns the distance between minor tick marks along the slider's value
929       * scale.
930       *
931       * @return The distance between minor tick marks along the slider's value
932       *     scale.
933       *
934       * @see #setMinorTickSpacing(int)
935       */
936      public int getMinorTickSpacing()
937      {
938        return minorTickSpacing;
939      }
940    
941      /**
942       * Sets the distance between minor tick marks along the slider's value scale,
943       * and sends a {@link PropertyChangeEvent} (with the property name
944       * "minorTickSpacing") to all registered listeners.
945       *
946       * @param spacing  the distance between minor tick marks.
947       *
948       * @see #getMinorTickSpacing()
949       */
950      public void setMinorTickSpacing(int spacing)
951      {
952        if (minorTickSpacing != spacing)
953          {
954            int oldSpacing = minorTickSpacing;
955            minorTickSpacing = spacing;
956            firePropertyChange("minorTickSpacing", oldSpacing, minorTickSpacing);
957            if (getPaintTicks())
958              repaint();
959          }
960      }
961    
962      /**
963       * Returns the flag that controls whether the slider thumb will snap to ticks.
964       * Sliders that snap to ticks will automatically move the thumb to the
965       * nearest tick mark.
966       *
967       * @return <code>true</code> if the slider thumb automatically.
968       *
969       * @see #setSnapToTicks(boolean)
970       */
971      public boolean getSnapToTicks()
972      {
973        return snapToTicks;
974      }
975    
976      /**
977       * Sets the flag that controls whether the slider thumb will snap to ticks
978       * and sends a {@link PropertyChangeEvent} (with the property name
979       * 'snapToTicks') to all registered listeners. Sliders that snap to ticks
980       * will automatically move the thumb to the nearest tick mark.
981       *
982       * @param snap  the new flag value.
983       *
984       * @see #getSnapToTicks()
985       */
986      public void setSnapToTicks(boolean snap)
987      {
988        if (snap != snapToTicks)
989          {
990            snapToTicks = snap;
991            firePropertyChange("snapToTicks", !snap, snap);
992          }
993      }
994    
995      /**
996       * Returns the flag that controls whether or not tick marks are painted along
997       * the slider's value scale.
998       *
999       * @return <code>true</code> if tick marks should be painted, and
1000       *     <code>false</code> if tick marks should not be painted.
1001       *
1002       * @see #setPaintTicks(boolean)
1003       */
1004      public boolean getPaintTicks()
1005      {
1006        return paintTicks;
1007      }
1008    
1009      /**
1010       * Sets the flag that controls whether or not tick marks are painted along
1011       * the slider's value scale, and sends a {@link PropertyChangeEvent} (with
1012       * the property name "paintTicks") to all registered listeners. In
1013       * addition to setting this property to <code>true</code>, one or both of the
1014       * minor tick spacing and major tick spacing attributes must be set to a
1015       * value greater than 0 in order for ticks to be painted.
1016       *
1017       * @param paint Whether ticks will be painted.
1018       *
1019       * @see #getPaintTicks()
1020       */
1021      public void setPaintTicks(boolean paint)
1022      {
1023        if (paint != paintTicks)
1024          {
1025            boolean oldPaintTicks = paintTicks;
1026            paintTicks = paint;
1027            firePropertyChange("paintTicks", oldPaintTicks, paintTicks);
1028            revalidate();
1029            repaint();
1030          }
1031      }
1032    
1033      /**
1034       * Returns the flag that controls whether or not the track is painted.
1035       *
1036       * @return Whether the track will be painted.
1037       *
1038       * @see #setPaintTrack(boolean)
1039       */
1040      public boolean getPaintTrack()
1041      {
1042        return paintTrack;
1043      }
1044    
1045      /**
1046       * Sets the flag that controls whether or not the track is painted, and
1047       * sends a {@link PropertyChangeEvent} (for the "paintTrack" property) to all
1048       * registered listeners.
1049       *
1050       * @param paint Whether the track will be painted.
1051       *
1052       * @see #getPaintTrack()
1053       */
1054      public void setPaintTrack(boolean paint)
1055      {
1056        if (paintTrack != paint)
1057        {
1058          paintTrack = paint;
1059          firePropertyChange("paintTrack", !paint, paint);
1060          repaint();
1061        }
1062      }
1063    
1064      /**
1065       * Returns the flag that controls whether or not labels are painted for the
1066       * tick marks along the slider.
1067       *
1068       * @return Whether labels will be painted.
1069       *
1070       * @see #setPaintLabels(boolean)
1071       */
1072      public boolean getPaintLabels()
1073      {
1074        return paintLabels;
1075      }
1076    
1077      /**
1078       * Sets the flag that controls whether or not labels are painted for the
1079       * tick marks along the slider and sends a {@link PropertyChangeEvent} (with
1080       * the property name "paintLabels") to all registered listeners.
1081       *
1082       * @param paint Whether labels will be painted.
1083       *
1084       * @see #getPaintLabels()
1085       */
1086      public void setPaintLabels(boolean paint)
1087      {
1088        if (paint != paintLabels)
1089          {
1090            paintLabels = paint;
1091            if (paint && majorTickSpacing > 0 && labelTable == null)
1092              setLabelTable(createStandardLabels(majorTickSpacing));
1093            firePropertyChange("paintLabels", !paint, paint);
1094            revalidate();
1095            repaint();
1096          }
1097      }
1098    
1099      /**
1100       * Returns an implementation-dependent string describing the attributes of
1101       * this <code>JSlider</code>.
1102       *
1103       * @return A string describing the attributes of this <code>JSlider</code>
1104       *         (never <code>null</code>).
1105       */
1106      protected String paramString()
1107      {
1108        String superParamStr = super.paramString();
1109        CPStringBuilder sb = new CPStringBuilder();
1110        sb.append(",isInverted=").append(getInverted());
1111        sb.append(",majorTickSpacing=").append(getMajorTickSpacing());
1112        sb.append(",minorTickSpacing=").append(getMinorTickSpacing());
1113        sb.append(",orientation=");
1114        if (orientation == HORIZONTAL)
1115          sb.append("HORIZONTAL");
1116        else
1117          sb.append("VERTICAL");
1118        sb.append(",paintLabels=").append(getPaintLabels());
1119        sb.append(",paintTicks=").append(getPaintTicks());
1120        sb.append(",paintTrack=").append(getPaintTrack());
1121        sb.append(",snapToTicks=").append(getSnapToTicks());
1122    
1123        // the following is output by the reference implementation.  We don't
1124        // strictly need to replicate this. Perhaps it has some meaning, but
1125        // I couldn't determine it yet...
1126        sb.append(",snapToValue=true");
1127    
1128        return superParamStr + sb.toString();
1129      }
1130    
1131      /**
1132       * Returns the object that provides accessibility features for this
1133       * <code>JSlider</code> component.
1134       *
1135       * @return The accessible context (an instance of {@link AccessibleJSlider}).
1136       */
1137      public AccessibleContext getAccessibleContext()
1138      {
1139        if (accessibleContext == null)
1140          accessibleContext = new AccessibleJSlider();
1141    
1142        return accessibleContext;
1143      }
1144    }