libjava/classpath/javax/swing/JSlider.java

   1 /* JSlider.java --
   2    Copyright (C) 2002, 2004, 2005, 2006,  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing;
  40
  41 import java.awt.MenuContainer;
  42 import java.awt.image.ImageObserver;
  43 import java.beans.PropertyChangeEvent;
  44 import java.io.Serializable;
  45 import java.util.Dictionary;
  46 import java.util.Enumeration;
  47 import java.util.Hashtable;
  48
  49 import javax.accessibility.Accessible;
  50 import javax.accessibility.AccessibleContext;
  51 import javax.accessibility.AccessibleRole;
  52 import javax.accessibility.AccessibleState;
  53 import javax.accessibility.AccessibleStateSet;
  54 import javax.accessibility.AccessibleValue;
  55 import javax.swing.event.ChangeEvent;
  56 import javax.swing.event.ChangeListener;
  57 import javax.swing.plaf.SliderUI;
  58 import javax.swing.plaf.UIResource;
  59
  60 /**
  61  * A visual component that allows selection of a value within a
  62  * range by adjusting a thumb in a track. The values for the minimum,
  63  * maximum, extent and value are stored in a {@link
  64  * DefaultBoundedRangeModel}.
  65  * <p>
  66  * A <code>JSlider</code> component has the following properties:
  67  * </p>
  68  *
  69  * <table>
  70  * <tr><th> Property         </th><th> Stored in </th><th> Bound? </th></tr>
  71  * <tr><td> extent           </td><td> model     </td><td> no     </td></tr>
  72  * <tr><td> inverted         </td><td> slider    </td><td> yes    </td></tr>
  73  * <tr><td> labelTable       </td><td> slider    </td><td> yes    </td></tr>
  74  * <tr><td> majorTickSpacing </td><td> slider    </td><td> yes    </td></tr>
  75  * <tr><td> maximum          </td><td> model     </td><td> yes     </td></tr>
  76  * <tr><td> minimum          </td><td> model     </td><td> yes     </td></tr>
  77  * <tr><td> minorTickSpacing </td><td> slider    </td><td> yes    </td></tr>
  78  * <tr><td> model            </td><td> slider    </td><td> yes    </td></tr>
  79  * <tr><td> orientation      </td><td> slider    </td><td> yes    </td></tr>
  80  * <tr><td> paintLabels      </td><td> slider    </td><td> yes    </td></tr>
  81  * <tr><td> paintTicks       </td><td> slider    </td><td> yes    </td></tr>
  82  * <tr><td> snapToTicks      </td><td> slider    </td><td> yes     </td></tr>
  83  * <tr><td> value            </td><td> model     </td><td> no     </td></tr>
  84  * <tr><td> valueIsAdjusting </td><td> model     </td><td> no     </td></tr>
  85  * </table>
  86  *
  87  * <p>
  88  * The various behavioural aspects of these properties follows:
  89  * </p>
  90  *
  91  * <ul>
  92  * <li>
  93  * When a non-bound property stored in the slider changes, the slider fires
  94  * a {@link ChangeEvent} to its change listeners.
  95  * </li>
  96  * <li>
  97  * When a bound property stored in the slider changes, the slider fires a
  98  * {@link PropertyChangeEvent} to its property change listeners.
  99  * </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 }