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 }