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