1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package javax.swing.plaf.basic;

    27 

    28 import java.awt.Component;

    29 import java.awt.Container;

    30 import java.awt.Adjustable;

    31 import java.awt.event.*;

    32 import java.awt.FontMetrics;

    33 import java.awt.Graphics;

    34 import java.awt.Dimension;

    35 import java.awt.Rectangle;

    36 import java.awt.Point;

    37 import java.awt.Insets;

    38 import java.awt.Color;

    39 import java.awt.IllegalComponentStateException;

    40 import java.awt.Polygon;

    41 import java.beans.*;

    42 import java.util.Dictionary;

    43 import java.util.Enumeration;

    44 

    45 import javax.swing.border.AbstractBorder;

    46 

    47 import javax.swing.*;

    48 import javax.swing.event.*;

    49 import javax.swing.plaf.*;

    50 import sun.swing.DefaultLookup;

    51 import sun.swing.UIAction;

    52 

    53 

    54 /**

    55  * A Basic L&F implementation of SliderUI.

    56  *

    57  * @author Tom Santos

    58  */

    59 public class BasicSliderUI extends SliderUI{

    60     // Old actions forward to an instance of this.

    61     private static final Actions SHARED_ACTION = new Actions();

    62 

    63     public static final int POSITIVE_SCROLL = +1;

    64     public static final int NEGATIVE_SCROLL = -1;

    65     public static final int MIN_SCROLL = -2;

    66     public static final int MAX_SCROLL = +2;

    67 

    68     protected Timer scrollTimer;

    69     protected JSlider slider;

    70 

    71     protected Insets focusInsets = null;

    72     protected Insets insetCache = null;

    73     protected boolean leftToRightCache = true;

    74     protected Rectangle focusRect = null;

    75     protected Rectangle contentRect = null;

    76     protected Rectangle labelRect = null;

    77     protected Rectangle tickRect = null;

    78     protected Rectangle trackRect = null;

    79     protected Rectangle thumbRect = null;

    80 

    81     protected int trackBuffer = 0;  // The distance that the track is from the side of the control

    82 

    83     private transient boolean isDragging;

    84 

    85     protected TrackListener trackListener;

    86     protected ChangeListener changeListener;

    87     protected ComponentListener componentListener;

    88     protected FocusListener focusListener;

    89     protected ScrollListener scrollListener;

    90     protected PropertyChangeListener propertyChangeListener;

    91     private Handler handler;

    92     private int lastValue;

    93 

    94     // Colors

    95     private Color shadowColor;

    96     private Color highlightColor;

    97     private Color focusColor;

    98 

    99     /**

   100      * Whther or not sameLabelBaselines is up to date.

   101      */

   102     private boolean checkedLabelBaselines;

   103     /**

   104      * Whether or not all the entries in the labeltable have the same

   105      * baseline.

   106      */

   107     private boolean sameLabelBaselines;

   108 

   109 

   110     protected Color getShadowColor() {

   111         return shadowColor;

   112     }

   113 

   114     protected Color getHighlightColor() {

   115         return highlightColor;

   116     }

   117 

   118     protected Color getFocusColor() {

   119         return focusColor;

   120     }

   121 

   122     /**

   123      * Returns true if the user is dragging the slider.

   124      *

   125      * @return true if the user is dragging the slider

   126      * @since 1.5

   127      */

   128     protected boolean isDragging() {

   129         return isDragging;

   130     }

   131 

   132     /////////////////////////////////////////////////////////////////////////////

   133     // ComponentUI Interface Implementation methods

   134     /////////////////////////////////////////////////////////////////////////////

   135     public static ComponentUI createUI(JComponent b)    {

   136         return new BasicSliderUI((JSlider)b);

   137     }

   138 

   139     public BasicSliderUI(JSlider b)   {

   140     }

   141 

   142     public void installUI(JComponent c)   {

   143         slider = (JSlider) c;

   144 

   145         checkedLabelBaselines = false;

   146 

   147         slider.setEnabled(slider.isEnabled());

   148         LookAndFeel.installProperty(slider, "opaque", Boolean.TRUE);

   149 

   150         isDragging = false;

   151         trackListener = createTrackListener( slider );

   152         changeListener = createChangeListener( slider );

   153         componentListener = createComponentListener( slider );

   154         focusListener = createFocusListener( slider );

   155         scrollListener = createScrollListener( slider );

   156         propertyChangeListener = createPropertyChangeListener( slider );

   157 

   158         installDefaults( slider );

   159         installListeners( slider );

   160         installKeyboardActions( slider );

   161 

   162         scrollTimer = new Timer( 100, scrollListener );

   163         scrollTimer.setInitialDelay( 300 );

   164 

   165         insetCache = slider.getInsets();

   166         leftToRightCache = BasicGraphicsUtils.isLeftToRight(slider);

   167         focusRect = new Rectangle();

   168         contentRect = new Rectangle();

   169         labelRect = new Rectangle();

   170         tickRect = new Rectangle();

   171         trackRect = new Rectangle();

   172         thumbRect = new Rectangle();

   173         lastValue = slider.getValue();

   174 

   175         calculateGeometry(); // This figures out where the labels, ticks, track, and thumb are.

   176     }

   177 

   178     public void uninstallUI(JComponent c) {

   179         if ( c != slider )

   180             throw new IllegalComponentStateException(

   181                                                     this + " was asked to deinstall() "

   182                                                     + c + " when it only knows about "

   183                                                     + slider + ".");

   184 

   185         LookAndFeel.uninstallBorder(slider);

   186 

   187         scrollTimer.stop();

   188         scrollTimer = null;

   189 

   190         uninstallListeners( slider );

   191         uninstallKeyboardActions(slider);

   192 

   193         focusInsets = null;

   194         insetCache = null;

   195         leftToRightCache = true;

   196         focusRect = null;

   197         contentRect = null;

   198         labelRect = null;

   199         tickRect = null;

   200         trackRect = null;

   201         thumbRect = null;

   202         trackListener = null;

   203         changeListener = null;

   204         componentListener = null;

   205         focusListener = null;

   206         scrollListener = null;

   207         propertyChangeListener = null;

   208         slider = null;

   209     }

   210 

   211     protected void installDefaults( JSlider slider ) {

   212         LookAndFeel.installBorder(slider, "Slider.border");

   213         LookAndFeel.installColorsAndFont(slider, "Slider.background",

   214                                          "Slider.foreground", "Slider.font");

   215         highlightColor = UIManager.getColor("Slider.highlight");

   216 

   217         shadowColor = UIManager.getColor("Slider.shadow");

   218         focusColor = UIManager.getColor("Slider.focus");

   219 

   220         focusInsets = (Insets)UIManager.get( "Slider.focusInsets" );

   221     }

   222 

   223     protected TrackListener createTrackListener(JSlider slider) {

   224         return new TrackListener();

   225     }

   226 

   227     protected ChangeListener createChangeListener(JSlider slider) {

   228         return getHandler();

   229     }

   230 

   231     protected ComponentListener createComponentListener(JSlider slider) {

   232         return getHandler();

   233     }

   234 

   235     protected FocusListener createFocusListener(JSlider slider) {

   236         return getHandler();

   237     }

   238 

   239     protected ScrollListener createScrollListener( JSlider slider ) {

   240         return new ScrollListener();

   241     }

   242 

   243     protected PropertyChangeListener createPropertyChangeListener(

   244             JSlider slider) {

   245         return getHandler();

   246     }

   247 

   248     private Handler getHandler() {

   249         if (handler == null) {

   250             handler = new Handler();

   251         }

   252         return handler;

   253     }

   254 

   255     protected void installListeners( JSlider slider ) {

   256         slider.addMouseListener(trackListener);

   257         slider.addMouseMotionListener(trackListener);

   258         slider.addFocusListener(focusListener);

   259         slider.addComponentListener(componentListener);

   260         slider.addPropertyChangeListener( propertyChangeListener );

   261         slider.getModel().addChangeListener(changeListener);

   262     }

   263 

   264     protected void uninstallListeners( JSlider slider ) {

   265         slider.removeMouseListener(trackListener);

   266         slider.removeMouseMotionListener(trackListener);

   267         slider.removeFocusListener(focusListener);

   268         slider.removeComponentListener(componentListener);

   269         slider.removePropertyChangeListener( propertyChangeListener );

   270         slider.getModel().removeChangeListener(changeListener);

   271         handler = null;

   272     }

   273 

   274     protected void installKeyboardActions( JSlider slider ) {

   275         InputMap km = getInputMap(JComponent.WHEN_FOCUSED, slider);

   276         SwingUtilities.replaceUIInputMap(slider, JComponent.WHEN_FOCUSED, km);

   277         LazyActionMap.installLazyActionMap(slider, BasicSliderUI.class,

   278                 "Slider.actionMap");

   279     }

   280 

   281     InputMap getInputMap(int condition, JSlider slider) {

   282         if (condition == JComponent.WHEN_FOCUSED) {

   283             InputMap keyMap = (InputMap)DefaultLookup.get(slider, this,

   284                   "Slider.focusInputMap");

   285             InputMap rtlKeyMap;

   286 

   287             if (slider.getComponentOrientation().isLeftToRight() ||

   288                 ((rtlKeyMap = (InputMap)DefaultLookup.get(slider, this,

   289                           "Slider.focusInputMap.RightToLeft")) == null)) {

   290                 return keyMap;

   291             } else {

   292                 rtlKeyMap.setParent(keyMap);

   293                 return rtlKeyMap;

   294             }

   295         }

   296         return null;

   297     }

   298 

   299     /**

   300      * Populates ComboBox's actions.

   301      */

   302     static void loadActionMap(LazyActionMap map) {

   303         map.put(new Actions(Actions.POSITIVE_UNIT_INCREMENT));

   304         map.put(new Actions(Actions.POSITIVE_BLOCK_INCREMENT));

   305         map.put(new Actions(Actions.NEGATIVE_UNIT_INCREMENT));

   306         map.put(new Actions(Actions.NEGATIVE_BLOCK_INCREMENT));

   307         map.put(new Actions(Actions.MIN_SCROLL_INCREMENT));

   308         map.put(new Actions(Actions.MAX_SCROLL_INCREMENT));

   309     }

   310 

   311     protected void uninstallKeyboardActions( JSlider slider ) {

   312         SwingUtilities.replaceUIActionMap(slider, null);

   313         SwingUtilities.replaceUIInputMap(slider, JComponent.WHEN_FOCUSED,

   314                                          null);

   315     }

   316 

   317 

   318     /**

   319      * Returns the baseline.

   320      *

   321      * @throws NullPointerException {@inheritDoc}

   322      * @throws IllegalArgumentException {@inheritDoc}

   323      * @see javax.swing.JComponent#getBaseline(int, int)

   324      * @since 1.6

   325      */

   326     public int getBaseline(JComponent c, int width, int height) {

   327         super.getBaseline(c, width, height);

   328         if (slider.getPaintLabels() && labelsHaveSameBaselines()) {

   329             FontMetrics metrics = slider.getFontMetrics(slider.getFont());

   330             Insets insets = slider.getInsets();

   331             Dimension thumbSize = getThumbSize();

   332             if (slider.getOrientation() == JSlider.HORIZONTAL) {

   333                 int tickLength = getTickLength();

   334                 int contentHeight = height - insets.top - insets.bottom -

   335                     focusInsets.top - focusInsets.bottom;

   336                 int thumbHeight = thumbSize.height;

   337                 int centerSpacing = thumbHeight;

   338                 if (slider.getPaintTicks()) {

   339                     centerSpacing += tickLength;

   340                 }

   341                 // Assume uniform labels.

   342                 centerSpacing += getHeightOfTallestLabel();

   343                 int trackY = insets.top + focusInsets.top +

   344                     (contentHeight - centerSpacing - 1) / 2;

   345                 int trackHeight = thumbHeight;

   346                 int tickY = trackY + trackHeight;

   347                 int tickHeight = tickLength;

   348                 if (!slider.getPaintTicks()) {

   349                     tickHeight = 0;

   350                 }

   351                 int labelY = tickY + tickHeight;

   352                 return labelY + metrics.getAscent();

   353             }

   354             else { // vertical

   355                 boolean inverted = slider.getInverted();

   356                 Integer value = inverted ? getLowestValue() :

   357                                            getHighestValue();

   358                 if (value != null) {

   359                     int thumbHeight = thumbSize.height;

   360                     int trackBuffer = Math.max(metrics.getHeight() / 2,

   361                                                thumbHeight / 2);

   362                     int contentY = focusInsets.top + insets.top;

   363                     int trackY = contentY + trackBuffer;

   364                     int trackHeight = height - focusInsets.top -

   365                         focusInsets.bottom - insets.top - insets.bottom -

   366                         trackBuffer - trackBuffer;

   367                     int yPosition = yPositionForValue(value, trackY,

   368                                                       trackHeight);

   369                     return yPosition - metrics.getHeight() / 2 +

   370                         metrics.getAscent();

   371                 }

   372             }

   373         }

   374         return 0;

   375     }

   376 

   377     /**

   378      * Returns an enum indicating how the baseline of the component

   379      * changes as the size changes.

   380      *

   381      * @throws NullPointerException {@inheritDoc}

   382      * @see javax.swing.JComponent#getBaseline(int, int)

   383      * @since 1.6

   384      */

   385     public Component.BaselineResizeBehavior getBaselineResizeBehavior(

   386             JComponent c) {

   387         super.getBaselineResizeBehavior(c);

   388         // NOTE: BasicSpinner really provides for CENTER_OFFSET, but

   389         // the default min/pref size is smaller than it should be

   390         // so that getBaseline() doesn't implement the contract

   391         // for CENTER_OFFSET as defined in Component.

   392         return Component.BaselineResizeBehavior.OTHER;

   393     }

   394 

   395     /**

   396      * Returns true if all the labels from the label table have the same

   397      * baseline.

   398      *

   399      * @return true if all the labels from the label table have the

   400      *         same baseline

   401      * @since 1.6

   402      */

   403     protected boolean labelsHaveSameBaselines() {

   404         if (!checkedLabelBaselines) {

   405             checkedLabelBaselines = true;

   406             Dictionary dictionary = slider.getLabelTable();

   407             if (dictionary != null) {

   408                 sameLabelBaselines = true;

   409                 Enumeration elements = dictionary.elements();

   410                 int baseline = -1;

   411                 while (elements.hasMoreElements()) {

   412                     Component label = (Component)elements.nextElement();

   413                     Dimension pref = label.getPreferredSize();

   414                     int labelBaseline = label.getBaseline(pref.width,

   415                                                           pref.height);

   416                     if (labelBaseline >= 0) {

   417                         if (baseline == -1) {

   418                             baseline = labelBaseline;

   419                         }

   420                         else if (baseline != labelBaseline) {

   421                             sameLabelBaselines = false;

   422                             break;

   423                         }

   424                     }

   425                     else {

   426                         sameLabelBaselines = false;

   427                         break;

   428                     }

   429                 }

   430             }

   431             else {

   432                 sameLabelBaselines = false;

   433             }

   434         }

   435         return sameLabelBaselines;

   436     }

   437 

   438     public Dimension getPreferredHorizontalSize() {

   439         Dimension horizDim = (Dimension)DefaultLookup.get(slider,

   440                 this, "Slider.horizontalSize");

   441         if (horizDim == null) {

   442             horizDim = new Dimension(200, 21);

   443         }

   444         return horizDim;

   445     }

   446 

   447     public Dimension getPreferredVerticalSize() {

   448         Dimension vertDim = (Dimension)DefaultLookup.get(slider,

   449                 this, "Slider.verticalSize");

   450         if (vertDim == null) {

   451             vertDim = new Dimension(21, 200);

   452         }

   453         return vertDim;

   454     }

   455 

   456     public Dimension getMinimumHorizontalSize() {

   457         Dimension minHorizDim = (Dimension)DefaultLookup.get(slider,

   458                 this, "Slider.minimumHorizontalSize");

   459         if (minHorizDim == null) {

   460             minHorizDim = new Dimension(36, 21);

   461         }

   462         return minHorizDim;

   463     }

   464 

   465     public Dimension getMinimumVerticalSize() {

   466         Dimension minVertDim = (Dimension)DefaultLookup.get(slider,

   467                 this, "Slider.minimumVerticalSize");

   468         if (minVertDim == null) {

   469             minVertDim = new Dimension(21, 36);

   470         }

   471         return minVertDim;

   472     }

   473 

   474     public Dimension getPreferredSize(JComponent c)    {

   475         recalculateIfInsetsChanged();

   476         Dimension d;

   477         if ( slider.getOrientation() == JSlider.VERTICAL ) {

   478             d = new Dimension(getPreferredVerticalSize());

   479             d.width = insetCache.left + insetCache.right;

   480             d.width += focusInsets.left + focusInsets.right;

   481             d.width += trackRect.width + tickRect.width + labelRect.width;

   482         }

   483         else {

   484             d = new Dimension(getPreferredHorizontalSize());

   485             d.height = insetCache.top + insetCache.bottom;

   486             d.height += focusInsets.top + focusInsets.bottom;

   487             d.height += trackRect.height + tickRect.height + labelRect.height;

   488         }

   489 

   490         return d;

   491     }

   492 

   493     public Dimension getMinimumSize(JComponent c)  {

   494         recalculateIfInsetsChanged();

   495         Dimension d;

   496 

   497         if ( slider.getOrientation() == JSlider.VERTICAL ) {

   498             d = new Dimension(getMinimumVerticalSize());

   499             d.width = insetCache.left + insetCache.right;

   500             d.width += focusInsets.left + focusInsets.right;

   501             d.width += trackRect.width + tickRect.width + labelRect.width;

   502         }

   503         else {

   504             d = new Dimension(getMinimumHorizontalSize());

   505             d.height = insetCache.top + insetCache.bottom;

   506             d.height += focusInsets.top + focusInsets.bottom;

   507             d.height += trackRect.height + tickRect.height + labelRect.height;

   508         }

   509 

   510         return d;

   511     }

   512 

   513     public Dimension getMaximumSize(JComponent c) {

   514         Dimension d = getPreferredSize(c);

   515         if ( slider.getOrientation() == JSlider.VERTICAL ) {

   516             d.height = Short.MAX_VALUE;

   517         }

   518         else {

   519             d.width = Short.MAX_VALUE;

   520         }

   521 

   522         return d;

   523     }

   524 

   525     protected void calculateGeometry() {

   526         calculateFocusRect();

   527         calculateContentRect();

   528         calculateThumbSize();

   529         calculateTrackBuffer();

   530         calculateTrackRect();

   531         calculateTickRect();

   532         calculateLabelRect();

   533         calculateThumbLocation();

   534     }

   535 

   536     protected void calculateFocusRect() {

   537         focusRect.x = insetCache.left;

   538         focusRect.y = insetCache.top;

   539         focusRect.width = slider.getWidth() - (insetCache.left + insetCache.right);

   540         focusRect.height = slider.getHeight() - (insetCache.top + insetCache.bottom);

   541     }

   542 

   543     protected void calculateThumbSize() {

   544         Dimension size = getThumbSize();

   545         thumbRect.setSize( size.width, size.height );

   546     }

   547 

   548     protected void calculateContentRect() {

   549         contentRect.x = focusRect.x + focusInsets.left;

   550         contentRect.y = focusRect.y + focusInsets.top;

   551         contentRect.width = focusRect.width - (focusInsets.left + focusInsets.right);

   552         contentRect.height = focusRect.height - (focusInsets.top + focusInsets.bottom);

   553     }

   554 

   555     protected void calculateThumbLocation() {

   556         if ( slider.getSnapToTicks() ) {

   557             int sliderValue = slider.getValue();

   558             int snappedValue = sliderValue;

   559             int majorTickSpacing = slider.getMajorTickSpacing();

   560             int minorTickSpacing = slider.getMinorTickSpacing();

   561             int tickSpacing = 0;

   562 

   563             if ( minorTickSpacing > 0 ) {

   564                 tickSpacing = minorTickSpacing;

   565             }

   566             else if ( majorTickSpacing > 0 ) {

   567                 tickSpacing = majorTickSpacing;

   568             }

   569 

   570             if ( tickSpacing != 0 ) {

   571                 // If it's not on a tick, change the value

   572                 if ( (sliderValue - slider.getMinimum()) % tickSpacing != 0 ) {

   573                     float temp = (float)(sliderValue - slider.getMinimum()) / (float)tickSpacing;

   574                     int whichTick = Math.round( temp );

   575 

   576                     // This is the fix for the bug #6401380

   577                     if (temp - (int)temp == .5 && sliderValue < lastValue) {

   578                       whichTick --;

   579                     }

   580                     snappedValue = slider.getMinimum() + (whichTick * tickSpacing);

   581                 }

   582 

   583                 if( snappedValue != sliderValue ) {

   584                     slider.setValue( snappedValue );

   585                 }

   586             }

   587         }

   588 

   589         if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   590             int valuePosition = xPositionForValue(slider.getValue());

   591 

   592             thumbRect.x = valuePosition - (thumbRect.width / 2);

   593             thumbRect.y = trackRect.y;

   594         }

   595         else {

   596             int valuePosition = yPositionForValue(slider.getValue());

   597 

   598             thumbRect.x = trackRect.x;

   599             thumbRect.y = valuePosition - (thumbRect.height / 2);

   600         }

   601     }

   602 

   603     protected void calculateTrackBuffer() {

   604         if ( slider.getPaintLabels() && slider.getLabelTable()  != null ) {

   605             Component highLabel = getHighestValueLabel();

   606             Component lowLabel = getLowestValueLabel();

   607 

   608             if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   609                 trackBuffer = Math.max( highLabel.getBounds().width, lowLabel.getBounds().width ) / 2;

   610                 trackBuffer = Math.max( trackBuffer, thumbRect.width / 2 );

   611             }

   612             else {

   613                 trackBuffer = Math.max( highLabel.getBounds().height, lowLabel.getBounds().height ) / 2;

   614                 trackBuffer = Math.max( trackBuffer, thumbRect.height / 2 );

   615             }

   616         }

   617         else {

   618             if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   619                 trackBuffer = thumbRect.width / 2;

   620             }

   621             else {

   622                 trackBuffer = thumbRect.height / 2;

   623             }

   624         }

   625     }

   626 

   627 

   628     protected void calculateTrackRect() {

   629         int centerSpacing = 0; // used to center sliders added using BorderLayout.CENTER (bug 4275631)

   630         if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   631             centerSpacing = thumbRect.height;

   632             if ( slider.getPaintTicks() ) centerSpacing += getTickLength();

   633             if ( slider.getPaintLabels() ) centerSpacing += getHeightOfTallestLabel();

   634             trackRect.x = contentRect.x + trackBuffer;

   635             trackRect.y = contentRect.y + (contentRect.height - centerSpacing - 1)/2;

   636             trackRect.width = contentRect.width - (trackBuffer * 2);

   637             trackRect.height = thumbRect.height;

   638         }

   639         else {

   640             centerSpacing = thumbRect.width;

   641             if (BasicGraphicsUtils.isLeftToRight(slider)) {

   642                 if ( slider.getPaintTicks() ) centerSpacing += getTickLength();

   643                 if ( slider.getPaintLabels() ) centerSpacing += getWidthOfWidestLabel();

   644             } else {

   645                 if ( slider.getPaintTicks() ) centerSpacing -= getTickLength();

   646                 if ( slider.getPaintLabels() ) centerSpacing -= getWidthOfWidestLabel();

   647             }

   648             trackRect.x = contentRect.x + (contentRect.width - centerSpacing - 1)/2;

   649             trackRect.y = contentRect.y + trackBuffer;

   650             trackRect.width = thumbRect.width;

   651             trackRect.height = contentRect.height - (trackBuffer * 2);

   652         }

   653 

   654     }

   655 

   656     /**

   657      * Gets the height of the tick area for horizontal sliders and the width of the

   658      * tick area for vertical sliders.  BasicSliderUI uses the returned value to

   659      * determine the tick area rectangle.  If you want to give your ticks some room,

   660      * make this larger than you need and paint your ticks away from the sides in paintTicks().

   661      */

   662     protected int getTickLength() {

   663         return 8;

   664     }

   665 

   666     protected void calculateTickRect() {

   667         if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   668             tickRect.x = trackRect.x;

   669             tickRect.y = trackRect.y + trackRect.height;

   670             tickRect.width = trackRect.width;

   671             tickRect.height = (slider.getPaintTicks()) ? getTickLength() : 0;

   672         }

   673         else {

   674             tickRect.width = (slider.getPaintTicks()) ? getTickLength() : 0;

   675             if(BasicGraphicsUtils.isLeftToRight(slider)) {

   676                 tickRect.x = trackRect.x + trackRect.width;

   677             }

   678             else {

   679                 tickRect.x = trackRect.x - tickRect.width;

   680             }

   681             tickRect.y = trackRect.y;

   682             tickRect.height = trackRect.height;

   683         }

   684     }

   685 

   686     protected void calculateLabelRect() {

   687         if ( slider.getPaintLabels() ) {

   688             if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   689                 labelRect.x = tickRect.x - trackBuffer;

   690                 labelRect.y = tickRect.y + tickRect.height;

   691                 labelRect.width = tickRect.width + (trackBuffer * 2);

   692                 labelRect.height = getHeightOfTallestLabel();

   693             }

   694             else {

   695                 if(BasicGraphicsUtils.isLeftToRight(slider)) {

   696                     labelRect.x = tickRect.x + tickRect.width;

   697                     labelRect.width = getWidthOfWidestLabel();

   698                 }

   699                 else {

   700                     labelRect.width = getWidthOfWidestLabel();

   701                     labelRect.x = tickRect.x - labelRect.width;

   702                 }

   703                 labelRect.y = tickRect.y - trackBuffer;

   704                 labelRect.height = tickRect.height + (trackBuffer * 2);

   705             }

   706         }

   707         else {

   708             if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   709                 labelRect.x = tickRect.x;

   710                 labelRect.y = tickRect.y + tickRect.height;

   711                 labelRect.width = tickRect.width;

   712                 labelRect.height = 0;

   713             }

   714             else {

   715                 if(BasicGraphicsUtils.isLeftToRight(slider)) {

   716                     labelRect.x = tickRect.x + tickRect.width;

   717                 }

   718                 else {

   719                     labelRect.x = tickRect.x;

   720                 }

   721                 labelRect.y = tickRect.y;

   722                 labelRect.width = 0;

   723                 labelRect.height = tickRect.height;

   724             }

   725         }

   726     }

   727 

   728     protected Dimension getThumbSize() {

   729         Dimension size = new Dimension();

   730 

   731         if ( slider.getOrientation() == JSlider.VERTICAL ) {

   732             size.width = 20;

   733             size.height = 11;

   734         }

   735         else {

   736             size.width = 11;

   737             size.height = 20;

   738         }

   739 

   740         return size;

   741     }

   742 

   743     public class PropertyChangeHandler implements PropertyChangeListener {

   744         // NOTE: This class exists only for backward compatability. All

   745         // its functionality has been moved into Handler. If you need to add

   746         // new functionality add it to the Handler, but make sure this

   747         // class calls into the Handler.

   748         public void propertyChange( PropertyChangeEvent e ) {

   749             getHandler().propertyChange(e);

   750         }

   751     }

   752 

   753     protected int getWidthOfWidestLabel() {

   754         Dictionary dictionary = slider.getLabelTable();

   755         int widest = 0;

   756         if ( dictionary != null ) {

   757             Enumeration keys = dictionary.keys();

   758             while ( keys.hasMoreElements() ) {

   759                 Component label = (Component)dictionary.get( keys.nextElement() );

   760                 widest = Math.max( label.getPreferredSize().width, widest );

   761             }

   762         }

   763         return widest;

   764     }

   765 

   766     protected int getHeightOfTallestLabel() {

   767         Dictionary dictionary = slider.getLabelTable();

   768         int tallest = 0;

   769         if ( dictionary != null ) {

   770             Enumeration keys = dictionary.keys();

   771             while ( keys.hasMoreElements() ) {

   772                 Component label = (Component)dictionary.get( keys.nextElement() );

   773                 tallest = Math.max( label.getPreferredSize().height, tallest );

   774             }

   775         }

   776         return tallest;

   777     }

   778 

   779     protected int getWidthOfHighValueLabel() {

   780         Component label = getHighestValueLabel();

   781         int width = 0;

   782 

   783         if ( label != null ) {

   784             width = label.getPreferredSize().width;

   785         }

   786 

   787         return width;

   788     }

   789 

   790     protected int getWidthOfLowValueLabel() {

   791         Component label = getLowestValueLabel();

   792         int width = 0;

   793 

   794         if ( label != null ) {

   795             width = label.getPreferredSize().width;

   796         }

   797 

   798         return width;

   799     }

   800 

   801     protected int getHeightOfHighValueLabel() {

   802         Component label = getHighestValueLabel();

   803         int height = 0;

   804 

   805         if ( label != null ) {

   806             height = label.getPreferredSize().height;

   807         }

   808 

   809         return height;

   810     }

   811 

   812     protected int getHeightOfLowValueLabel() {

   813         Component label = getLowestValueLabel();

   814         int height = 0;

   815 

   816         if ( label != null ) {

   817             height = label.getPreferredSize().height;

   818         }

   819 

   820         return height;

   821     }

   822 

   823     protected boolean drawInverted() {

   824         if (slider.getOrientation()==JSlider.HORIZONTAL) {

   825             if(BasicGraphicsUtils.isLeftToRight(slider)) {

   826                 return slider.getInverted();

   827             } else {

   828                 return !slider.getInverted();

   829             }

   830         } else {

   831             return slider.getInverted();

   832         }

   833     }

   834 

   835     /**

   836      * Returns the biggest value that has an entry in the label table.

   837      *

   838      * @return biggest value that has an entry in the label table, or

   839      *         null.

   840      * @since 1.6

   841      */

   842     protected Integer getHighestValue() {

   843         Dictionary dictionary = slider.getLabelTable();

   844         if (dictionary != null) {

   845             Enumeration keys = dictionary.keys();

   846             int max = slider.getMinimum() - 1;

   847             while (keys.hasMoreElements()) {

   848                 max = Math.max(max, ((Integer)keys.nextElement()).intValue());

   849             }

   850             if (max == slider.getMinimum() - 1) {

   851                 return null;

   852             }

   853             return max;

   854         }

   855         return null;

   856     }

   857 

   858     /**

   859      * Returns the smallest value that has an entry in the label table.

   860      *

   861      * @return smallest value that has an entry in the label table, or

   862      *         null.

   863      * @since 1.6

   864      */

   865     protected Integer getLowestValue() {

   866         Dictionary dictionary = slider.getLabelTable();

   867         if (dictionary != null) {

   868             Enumeration keys = dictionary.keys();

   869             int min = slider.getMaximum() + 1;

   870             while (keys.hasMoreElements()) {

   871                 min = Math.min(min, ((Integer)keys.nextElement()).intValue());

   872             }

   873             if (min == slider.getMaximum() + 1) {

   874                 return null;

   875             }

   876             return min;

   877         }

   878         return null;

   879     }

   880 

   881 

   882     /**

   883      * Returns the label that corresponds to the highest slider value in the label table.

   884      * @see JSlider#setLabelTable

   885      */

   886     protected Component getLowestValueLabel() {

   887         Integer min = getLowestValue();

   888         if (min != null) {

   889             return (Component)slider.getLabelTable().get(min);

   890         }

   891         return null;

   892     }

   893 

   894     /**

   895      * Returns the label that corresponds to the lowest slider value in the label table.

   896      * @see JSlider#setLabelTable

   897      */

   898     protected Component getHighestValueLabel() {

   899         Integer max = getHighestValue();

   900         if (max != null) {

   901             return (Component)slider.getLabelTable().get(max);

   902         }

   903         return null;

   904     }

   905 

   906     public void paint( Graphics g, JComponent c )   {

   907         recalculateIfInsetsChanged();

   908         recalculateIfOrientationChanged();

   909         Rectangle clip = g.getClipBounds();

   910 

   911         if ( !clip.intersects(trackRect) && slider.getPaintTrack())

   912             calculateGeometry();

   913 

   914         if ( slider.getPaintTrack() && clip.intersects( trackRect ) ) {

   915             paintTrack( g );

   916         }

   917         if ( slider.getPaintTicks() && clip.intersects( tickRect ) ) {

   918             paintTicks( g );

   919         }

   920         if ( slider.getPaintLabels() && clip.intersects( labelRect ) ) {

   921             paintLabels( g );

   922         }

   923         if ( slider.hasFocus() && clip.intersects( focusRect ) ) {

   924             paintFocus( g );

   925         }

   926         if ( clip.intersects( thumbRect ) ) {

   927             paintThumb( g );

   928         }

   929     }

   930 

   931     protected void recalculateIfInsetsChanged() {

   932         Insets newInsets = slider.getInsets();

   933         if ( !newInsets.equals( insetCache ) ) {

   934             insetCache = newInsets;

   935             calculateGeometry();

   936         }

   937     }

   938 

   939     protected void recalculateIfOrientationChanged() {

   940         boolean ltr = BasicGraphicsUtils.isLeftToRight(slider);

   941         if ( ltr!=leftToRightCache ) {

   942             leftToRightCache = ltr;

   943             calculateGeometry();

   944         }

   945     }

   946 

   947     public void paintFocus(Graphics g)  {

   948         g.setColor( getFocusColor() );

   949 

   950         BasicGraphicsUtils.drawDashedRect( g, focusRect.x, focusRect.y,

   951                                            focusRect.width, focusRect.height );

   952     }

   953 

   954     public void paintTrack(Graphics g)  {

   955 

   956         Rectangle trackBounds = trackRect;

   957 

   958         if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

   959             int cy = (trackBounds.height / 2) - 2;

   960             int cw = trackBounds.width;

   961 

   962             g.translate(trackBounds.x, trackBounds.y + cy);

   963 

   964             g.setColor(getShadowColor());

   965             g.drawLine(0, 0, cw - 1, 0);

   966             g.drawLine(0, 1, 0, 2);

   967             g.setColor(getHighlightColor());

   968             g.drawLine(0, 3, cw, 3);

   969             g.drawLine(cw, 0, cw, 3);

   970             g.setColor(Color.black);

   971             g.drawLine(1, 1, cw-2, 1);

   972 

   973             g.translate(-trackBounds.x, -(trackBounds.y + cy));

   974         }

   975         else {

   976             int cx = (trackBounds.width / 2) - 2;

   977             int ch = trackBounds.height;

   978 

   979             g.translate(trackBounds.x + cx, trackBounds.y);

   980 

   981             g.setColor(getShadowColor());

   982             g.drawLine(0, 0, 0, ch - 1);

   983             g.drawLine(1, 0, 2, 0);

   984             g.setColor(getHighlightColor());

   985             g.drawLine(3, 0, 3, ch);

   986             g.drawLine(0, ch, 3, ch);

   987             g.setColor(Color.black);

   988             g.drawLine(1, 1, 1, ch-2);

   989 

   990             g.translate(-(trackBounds.x + cx), -trackBounds.y);

   991         }

   992     }

   993 

   994     public void paintTicks(Graphics g)  {

   995         Rectangle tickBounds = tickRect;

   996         int i;

   997         int maj, min, max;

   998         int w = tickBounds.width;

   999         int h = tickBounds.height;

  1000         int centerEffect, tickHeight;

  1001 

  1002         g.setColor(DefaultLookup.getColor(slider, this, "Slider.tickColor", Color.black));

  1003 

  1004         maj = slider.getMajorTickSpacing();

  1005         min = slider.getMinorTickSpacing();

  1006 

  1007         if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

  1008            g.translate( 0, tickBounds.y);

  1009 

  1010             int value = slider.getMinimum();

  1011             int xPos = 0;

  1012 

  1013             if ( slider.getMinorTickSpacing() > 0 ) {

  1014                 while ( value <= slider.getMaximum() ) {

  1015                     xPos = xPositionForValue( value );

  1016                     paintMinorTickForHorizSlider( g, tickBounds, xPos );

  1017                     value += slider.getMinorTickSpacing();

  1018                 }

  1019             }

  1020 

  1021             if ( slider.getMajorTickSpacing() > 0 ) {

  1022                 value = slider.getMinimum();

  1023 

  1024                 while ( value <= slider.getMaximum() ) {

  1025                     xPos = xPositionForValue( value );

  1026                     paintMajorTickForHorizSlider( g, tickBounds, xPos );

  1027                     value += slider.getMajorTickSpacing();

  1028                 }

  1029             }

  1030 

  1031             g.translate( 0, -tickBounds.y);

  1032         }

  1033         else {

  1034            g.translate(tickBounds.x, 0);

  1035 

  1036             int value = slider.getMinimum();

  1037             int yPos = 0;

  1038 

  1039             if ( slider.getMinorTickSpacing() > 0 ) {

  1040                 int offset = 0;

  1041                 if(!BasicGraphicsUtils.isLeftToRight(slider)) {

  1042                     offset = tickBounds.width - tickBounds.width / 2;

  1043                     g.translate(offset, 0);

  1044                 }

  1045 

  1046                 while ( value <= slider.getMaximum() ) {

  1047                     yPos = yPositionForValue( value );

  1048                     paintMinorTickForVertSlider( g, tickBounds, yPos );

  1049                     value += slider.getMinorTickSpacing();

  1050                 }

  1051 

  1052                 if(!BasicGraphicsUtils.isLeftToRight(slider)) {

  1053                     g.translate(-offset, 0);

  1054                 }

  1055             }

  1056 

  1057             if ( slider.getMajorTickSpacing() > 0 ) {

  1058                 value = slider.getMinimum();

  1059                 if(!BasicGraphicsUtils.isLeftToRight(slider)) {

  1060                     g.translate(2, 0);

  1061                 }

  1062 

  1063                 while ( value <= slider.getMaximum() ) {

  1064                     yPos = yPositionForValue( value );

  1065                     paintMajorTickForVertSlider( g, tickBounds, yPos );

  1066                     value += slider.getMajorTickSpacing();

  1067                 }

  1068 

  1069                 if(!BasicGraphicsUtils.isLeftToRight(slider)) {

  1070                     g.translate(-2, 0);

  1071                 }

  1072             }

  1073             g.translate(-tickBounds.x, 0);

  1074         }

  1075     }

  1076 

  1077     protected void paintMinorTickForHorizSlider( Graphics g, Rectangle tickBounds, int x ) {

  1078         g.drawLine( x, 0, x, tickBounds.height / 2 - 1 );

  1079     }

  1080 

  1081     protected void paintMajorTickForHorizSlider( Graphics g, Rectangle tickBounds, int x ) {

  1082         g.drawLine( x, 0, x, tickBounds.height - 2 );

  1083     }

  1084 

  1085     protected void paintMinorTickForVertSlider( Graphics g, Rectangle tickBounds, int y ) {

  1086         g.drawLine( 0, y, tickBounds.width / 2 - 1, y );

  1087     }

  1088 

  1089     protected void paintMajorTickForVertSlider( Graphics g, Rectangle tickBounds, int y ) {

  1090         g.drawLine( 0, y,  tickBounds.width - 2, y );

  1091     }

  1092 

  1093     public void paintLabels( Graphics g ) {

  1094         Rectangle labelBounds = labelRect;

  1095 

  1096         Dictionary dictionary = slider.getLabelTable();

  1097         if ( dictionary != null ) {

  1098             Enumeration keys = dictionary.keys();

  1099             int minValue = slider.getMinimum();

  1100             int maxValue = slider.getMaximum();

  1101             boolean enabled = slider.isEnabled();

  1102             while ( keys.hasMoreElements() ) {

  1103                 Integer key = (Integer)keys.nextElement();

  1104                 int value = key.intValue();

  1105                 if (value >= minValue && value <= maxValue) {

  1106                     Component label = (Component)dictionary.get( key );

  1107                     if (label instanceof JComponent) {

  1108                         ((JComponent)label).setEnabled(enabled);

  1109                     }

  1110                     if ( slider.getOrientation() == JSlider.HORIZONTAL ) {

  1111                         g.translate( 0, labelBounds.y );

  1112                         paintHorizontalLabel( g, value, label );

  1113                         g.translate( 0, -labelBounds.y );

  1114                     }

  1115                     else {

  1116                         int offset = 0;

  1117                         if (!BasicGraphicsUtils.isLeftToRight(slider)) {

  1118                             offset = labelBounds.width -

  1119                                 label.getPreferredSize().width;

  1120                         }

  1121                         g.translate( labelBounds.x + offset, 0 );

  1122                         paintVerticalLabel( g, value, label );

  1123                         g.translate( -labelBounds.x - offset, 0 );

  1124                     }

  1125                 }

  1126             }

  1127         }

  1128 

  1129     }

  1130 

  1131     /**

  1132      * Called for every label in the label table.  Used to draw the labels for horizontal sliders.

  1133      * The graphics have been translated to labelRect.y already.

  1134      * @see JSlider#setLabelTable

  1135      */