Merged gcj-eclipse branch to trunk.

[pf3gnuchains/gcc-fork.git] / libjava / classpath / javax / swing / plaf / basic / BasicSliderUI.java

/* BasicSliderUI.java --
   Copyright (C) 2004, 2005, 2006,  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package javax.swing.plaf.basic;

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Dictionary;
import java.util.Enumeration;

import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.BoundedRangeModel;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JSlider;
import javax.swing.LookAndFeel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.MouseInputAdapter;
import javax.swing.plaf.ActionMapUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.SliderUI;

/**
 * <p>
 * BasicSliderUI.java This is the UI delegate in the Basic look and feel that
 * paints JSliders.
 * </p>
 * 
 * <p>
 * The UI delegate keeps track of 6 rectangles that place the various parts of
 * the JSlider inside the component.
 * </p>
 * 
 * <p>
 * The rectangles are organized as follows:
 * </p>
 * <pre>
 *     +-------------------------------------------------------+ <-- focusRect
 *     |                                                       |
 *     |  +==+-------------------+==+--------------------+==+<------ contentRect
 *     |  |  |                   |  |<---thumbRect       |  |  |
 *     |  |  |    TRACK          |  |                    |<--------- trackRect
 *     |  |  +-------------------+==+--------------------+  |  |
 *     |  |  |                                           |  |  |
 *     |  |  |          TICKS GO HERE                    |<-------- tickRect
 *     |  |  |                                           |  |  |
 *     |  +==+-------------------------------------------+==+  |
 *     |  |  |                                           |  |  |
 *     |  |  |                                           |  |<----- labelRect
 *     |  |  |                 LABELS GO HERE            |  |  |
 *     |  |  |                                           |  |  |
 *     |  |  |                                           |  |  |
 *     |  |  |                                           |  |  |
 *     |  |  |                                           |  |  |
 *     |  |                                              |  |  |
 * </pre>
 * 
 * <p>
 * The space between the contentRect and the focusRect are the FocusInsets.
 * </p>
 * 
 * <p>
 * The space between the focusRect and the component bounds is the insetCache
 * which are the component's insets.
 * </p>
 * 
 * <p>
 * The top of the thumb is the top of the contentRect. The trackRect has to be
 * as tall as the thumb.
 * </p>
 * 
 * <p>
 * The trackRect and tickRect do not start from the left edge of the
 * focusRect. They are trackBuffer away from each side of the focusRect. This
 * is so that the thumb has room to move.
 * </p>
 * 
 * <p>
 * The labelRect does start right against the contentRect's left and right
 * edges and it gets all remaining space.
 * </p>
 */
public class BasicSliderUI extends SliderUI
{
  /**
   * Helper class that listens to the {@link JSlider}'s model for changes.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class ChangeHandler implements ChangeListener
  {
    /**
     * Called when the slider's model has been altered. The UI delegate should
     * recalculate any rectangles that are dependent on the model for their
     * positions and repaint.
     *
     * @param e A static {@link ChangeEvent} passed from the model.
     */
    public void stateChanged(ChangeEvent e)
    {
      // Maximum, minimum, and extent values will be taken
      // care of automatically when the slider is repainted.
      // Only thing that needs recalculation is the thumb.
      calculateThumbLocation();
      slider.repaint();
    }
  }

  /**
   * Helper class that listens for resize events.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class ComponentHandler extends ComponentAdapter
  {
    /**
     * Called when the size of the component changes. The UI delegate should
     * recalculate any rectangles that are dependent on the model for their
     * positions and repaint.
     *
     * @param e A {@link ComponentEvent}.
     */
    public void componentResized(ComponentEvent e)
    {
      calculateGeometry();
      slider.repaint();
    }
  }

  /**
   * Helper class that listens for focus events.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class FocusHandler implements FocusListener
  {
    /**
     * Called when the {@link JSlider} has gained focus.  It should repaint
     * the slider with the focus drawn.
     *
     * @param e A {@link FocusEvent}.
     */
    public void focusGained(FocusEvent e)
    {
      slider.repaint();
    }

    /**
     * Called when the {@link JSlider} has lost focus. It  should repaint the
     * slider without the focus drawn.
     *
     * @param e A {@link FocusEvent}.
     */
    public void focusLost(FocusEvent e)
    {
      slider.repaint();
    }
  }

  /**
   * Helper class that listens for changes to the properties of the {@link
   * JSlider}.
   */
  public class PropertyChangeHandler implements PropertyChangeListener
  {
    /**
     * Called when one of the properties change. The UI should recalculate any
     * rectangles if necessary and repaint.
     *
     * @param e A {@link PropertyChangeEvent}.
     */
    public void propertyChange(PropertyChangeEvent e)
    {
      // Check for orientation changes.
      String prop = e.getPropertyName();
      if (prop.equals("orientation")
          || prop.equals("inverted")
          || prop.equals("labelTable")
          || prop.equals("majorTickSpacing")
          || prop.equals("minorTickSpacing")
          || prop.equals("paintTicks")
          || prop.equals("paintTrack")
          || prop.equals("paintLabels"))
        {
          calculateGeometry();
          slider.repaint();
        }
      else if (e.getPropertyName().equals("model"))
        {
          BoundedRangeModel oldModel = (BoundedRangeModel) e.getOldValue();
          oldModel.removeChangeListener(changeListener);
          slider.getModel().addChangeListener(changeListener);
          calculateThumbLocation();
          slider.repaint();
        }
    }
  }

  /**
   * Helper class that listens to our swing timer. This class is responsible
   * for listening to the timer and moving the thumb in the proper direction
   * every interval.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class ScrollListener implements ActionListener
  {
    /** Indicates which direction the thumb should scroll. */
    private transient int direction;

    /** Indicates whether we should scroll in blocks or in units. */
    private transient boolean block;

    /**
     * Creates a new ScrollListener object.
     */
    public ScrollListener()
    {
      direction = POSITIVE_SCROLL;
      block = false;
    }

    /**
     * Creates a new ScrollListener object.
     *
     * @param dir The direction to scroll in.
     * @param block If movement will be in blocks.
     */
    public ScrollListener(int dir, boolean block)
    {
      direction = dir;
      this.block = block;
    }

    /**
     * Called every time the swing timer reaches its interval. If the thumb
     * needs to move, then this method will move the thumb one block or  unit
     * in the direction desired. Otherwise, the timer can be stopped.
     *
     * @param e An {@link ActionEvent}.
     */
    public void actionPerformed(ActionEvent e)
    {
      if (! trackListener.shouldScroll(direction))
        {
          scrollTimer.stop();
          return;
        }

      if (block)
        scrollByBlock(direction);
      else
        scrollByUnit(direction);
    }

    /**
     * Sets the direction to scroll in.
     *
     * @param direction The direction to scroll in.
     */
    public void setDirection(int direction)
    {
      this.direction = direction;
    }

    /**
     * Sets whether movement will be in blocks.
     *
     * @param block If movement will be in blocks.
     */
    public void setScrollByBlock(boolean block)
    {
      this.block = block;
    }
  }

  /**
   * Helper class that listens for mouse events.
   *
   * @specnote Apparently this class was intended to be protected,
   *           but was made public by a compiler bug and is now
   *           public for compatibility.
   */
  public class TrackListener extends MouseInputAdapter
  {
    /** The current X position of the mouse. */
    protected int currentMouseX;

    /** The current Y position of the mouse. */
    protected int currentMouseY;

    /**
     * The offset between the current slider value and the cursor's position.
     */
    protected int offset;

    /**
     * Called when the mouse has been dragged. This should find the mouse's
     * current position and adjust the value of the {@link JSlider}
     * accordingly.
     *
     * @param e A {@link MouseEvent}
     */
    public void mouseDragged(MouseEvent e)
    {
      dragging = true;
      if (slider.isEnabled())
        {
          currentMouseX = e.getX();
          currentMouseY = e.getY();
          if (slider.getValueIsAdjusting())
            {
              int value;
              if (slider.getOrientation() == JSlider.HORIZONTAL)
                value = valueForXPosition(currentMouseX) - offset;
              else
                value = valueForYPosition(currentMouseY) - offset;

              slider.setValue(value);
            }
        }
    }

    /**
     * Called when the mouse has moved over a component but no buttons have
     * been pressed yet.
     *
     * @param e A {@link MouseEvent}
     */
    public void mouseMoved(MouseEvent e)
    {
      // Don't care that we're moved unless we're dragging.
    }

    /**
     * Called when the mouse is pressed. When the press occurs on the thumb
     * itself, the {@link JSlider} should have its value set to where the
     * mouse was pressed. If the press occurs on the track, then the thumb
     * should move one block towards the direction of the mouse.
     *
     * @param e A {@link MouseEvent}
     */
    public void mousePressed(MouseEvent e)
    {
      if (slider.isEnabled())
        {
          currentMouseX = e.getX();
          currentMouseY = e.getY();

          int value;
          if (slider.getOrientation() == JSlider.HORIZONTAL)
            value = valueForXPosition(currentMouseX);
          else
            value = valueForYPosition(currentMouseY);

          if (slider.getSnapToTicks())
            value = findClosestTick(value);

          // If the thumb is hit, then we don't need to set the timers to 
          // move it. 
          if (! thumbRect.contains(e.getPoint()))
            {
              // The mouse has hit some other part of the slider.
              // The value moves no matter where in the slider you hit.
              if (value > slider.getValue())
                scrollDueToClickInTrack(POSITIVE_SCROLL);
              else
                scrollDueToClickInTrack(NEGATIVE_SCROLL);
            }
          else
            {
              slider.setValueIsAdjusting(true);
              offset = value - slider.getValue();
            }
        }
    }

    /**
     * Called when the mouse is released.  This should stop the timer that
     * scrolls the thumb.
     *
     * @param e A {@link MouseEvent}
     */
    public void mouseReleased(MouseEvent e)
    {
      dragging = false;
      if (slider.isEnabled())
        {
          currentMouseX = e.getX();
          currentMouseY = e.getY();

          if (slider.getValueIsAdjusting())
            {
              slider.setValueIsAdjusting(false);
              if (slider.getSnapToTicks())
                slider.setValue(findClosestTick(slider.getValue()));
            }
          if (scrollTimer != null)
            scrollTimer.stop();
        }
      slider.repaint();
    }

    /**
     * Indicates whether the thumb should scroll in the given direction.
     *
     * @param direction The direction to check.
     *
     * @return True if the thumb should move in that direction.
     */
    public boolean shouldScroll(int direction)
    {
      int value;
      if (slider.getOrientation() == JSlider.HORIZONTAL)
        value = valueForXPosition(currentMouseX);
      else
        value = valueForYPosition(currentMouseY);

      if (direction == POSITIVE_SCROLL)
        return value > slider.getValue();
      else
        return value < slider.getValue();
    }
  }

  /**
   * This class is no longer used as of JDK1.3.
   */
  public class ActionScroller extends AbstractAction
  {
    /**
     * Not used.
     *
     * @param slider not used
     * @param dir not used
     * @param block not used
     */
    public ActionScroller(JSlider slider, int dir, boolean block)
    {
      // Not used.
    }

    /**
     * Not used.
     *
     * @param event not used
     */
    public void actionPerformed(ActionEvent event)
    {
      // Not used.
    }
  }

  /** Listener for changes from the model. */
  protected ChangeListener changeListener;

  /** Listener for changes to the {@link JSlider}. */
  protected PropertyChangeListener propertyChangeListener;

  /** Listener for the scrollTimer. */
  protected ScrollListener scrollListener;

  /** Listener for component resizing. */
  protected ComponentListener componentListener;

  /** Listener for focus handling. */
  protected FocusListener focusListener;

  /** Listener for mouse events. */
  protected TrackListener trackListener;

  /** The insets between the FocusRectangle and the ContentRectangle. */
  protected Insets focusInsets;

  /** The {@link JSlider}'s insets. */
  protected Insets insetCache;

  /** Rectangle describing content bounds. See diagram above. */
  protected Rectangle contentRect;

  /** Rectangle describing focus bounds. See diagram above. */
  protected Rectangle focusRect;

  /** Rectangle describing the thumb's bounds. See diagram above. */
  protected Rectangle thumbRect;

  /** Rectangle describing the tick bounds. See diagram above. */
  protected Rectangle tickRect;

  /** Rectangle describing the label bounds. See diagram above. */
  protected Rectangle labelRect;

  /** Rectangle describing the track bounds. See diagram above. */
  protected Rectangle trackRect;

  /** FIXME: use this somewhere. */
  public static final int MAX_SCROLL = 2;

  /** FIXME: use this somewhere. */
  public static final int MIN_SCROLL = -2;

  /** A constant describing scrolling towards the minimum. */
  public static final int NEGATIVE_SCROLL = -1;

  /** A constant describing scrolling towards the maximum. */
  public static final int POSITIVE_SCROLL = 1;

  /** The gap between the edges of the contentRect and trackRect. */
  protected int trackBuffer;

  /** Whether this slider is actually drawn left to right. */
  protected boolean leftToRightCache;

  /** A timer that periodically moves the thumb. */
  protected Timer scrollTimer;

  /** A reference to the {@link JSlider} that this UI was created for. */
  protected JSlider slider;

  /** The shadow color. */
  private transient Color shadowColor;

  /** The highlight color. */
  private transient Color highlightColor;

  /** The focus color. */
  private transient Color focusColor;

  /** True if the user is dragging the slider. */
  boolean dragging;

  /**
   * Creates a new Basic look and feel Slider UI.
   *
   * @param b The {@link JSlider} that this UI was created for.
   */
  public BasicSliderUI(JSlider b)
  {
    super();
  }

  /**
   * Returns true if the user is dragging the slider.
   * 
   * @return true if the slider is being dragged.
   * 
   * @since 1.5
   */
  protected boolean isDragging()
  {
    return dragging;
  }
  
  /**
   * Gets the shadow color to be used for this slider. The shadow color is the
   * color used for drawing the top and left edges of the track.
   *
   * @return The shadow color.
   */
  protected Color getShadowColor()
  {
    return shadowColor;
  }

  /**
   * Gets the highlight color to be used for this slider. The highlight color
   * is the color used for drawing the bottom and right edges of the track.
   *
   * @return The highlight color.
   */
  protected Color getHighlightColor()
  {
    return highlightColor;
  }

  /**
   * Gets the focus color to be used for this slider. The focus color is the
   * color used for drawing the focus rectangle when the component gains
   * focus.
   *
   * @return The focus color.
   */
  protected Color getFocusColor()
  {
    return focusColor;
  }

  /**
   * Factory method to create a BasicSliderUI for the given {@link
   * JComponent}, which should be a {@link JSlider}.
   *
   * @param b The {@link JComponent} a UI is being created for.
   *
   * @return A BasicSliderUI for the {@link JComponent}.
   */
  public static ComponentUI createUI(JComponent b)
  {
    return new BasicSliderUI((JSlider) b);
  }

  /**
   * Installs and initializes all fields for this UI delegate. Any properties
   * of the UI that need to be initialized and/or set to defaults will be
   * done now. It will also install any listeners necessary.
   *
   * @param c The {@link JComponent} that is having this UI installed.
   */
  public void installUI(JComponent c)
  {
    super.installUI(c);
    if (c instanceof JSlider)
      {
        slider = (JSlider) c;

        focusRect = new Rectangle();
        contentRect = new Rectangle();
        thumbRect = new Rectangle();
        trackRect = new Rectangle();
        tickRect = new Rectangle();
        labelRect = new Rectangle();

        insetCache = slider.getInsets();
        leftToRightCache = ! slider.getInverted();

        scrollTimer = new Timer(200, null);
        scrollTimer.setRepeats(true);

        installDefaults(slider);
        installListeners(slider);
        installKeyboardActions(slider);

        calculateFocusRect();

        calculateContentRect();
        calculateThumbSize();
        calculateTrackBuffer();
        calculateTrackRect();
        calculateThumbLocation();

        calculateTickRect();
        calculateLabelRect();
      }
  }

  /**
   * Performs the opposite of installUI. Any properties or resources that need
   * to be cleaned up will be done now. It will also uninstall any listeners
   * it has. In addition, any properties of this UI will be nulled.
   *
   * @param c The {@link JComponent} that is having this UI uninstalled.
   */
  public void uninstallUI(JComponent c)
  {
    super.uninstallUI(c);

    uninstallKeyboardActions(slider);
    uninstallListeners(slider);

    scrollTimer = null;

    focusRect = null;
    contentRect = null;
    thumbRect = null;
    trackRect = null;
    tickRect = null;
    labelRect = null;

    focusInsets = null;
  }

  /**
   * Initializes any default properties that this UI has from the defaults for
   * the Basic look and feel.
   *
   * @param slider The {@link JSlider} that is having this UI installed.
   */
  protected void installDefaults(JSlider slider)
  {
    LookAndFeel.installColors(slider, "Slider.background",
                              "Slider.foreground");
    LookAndFeel.installBorder(slider, "Slider.border");
    shadowColor = UIManager.getColor("Slider.shadow");
    highlightColor = UIManager.getColor("Slider.highlight");
    focusColor = UIManager.getColor("Slider.focus");
    focusInsets = UIManager.getInsets("Slider.focusInsets");
    slider.setOpaque(true);
  }

  /**
   * Creates a new {@link TrackListener}.
   *
   * @param slider The {@link JSlider} that this {@link TrackListener} is
   *        created for.
   *
   * @return A new {@link TrackListener}.
   */
  protected TrackListener createTrackListener(JSlider slider)
  {
    return new TrackListener();
  }

  /**
   * Creates a new {@link ChangeListener}.
   *
   * @param slider The {@link JSlider} that this {@link ChangeListener} is
   *        created for.
   *
   * @return A new {@link ChangeListener}.
   */
  protected ChangeListener createChangeListener(JSlider slider)
  {
    return new ChangeHandler();
  }

  /**
   * Creates a new {@link ComponentListener}.
   *
   * @param slider The {@link JSlider} that this {@link ComponentListener} is
   *        created for.
   *
   * @return A new {@link ComponentListener}.
   */
  protected ComponentListener createComponentListener(JSlider slider)
  {
    return new ComponentHandler();
  }

  /**
   * Creates a new {@link FocusListener}.
   *
   * @param slider The {@link JSlider} that this {@link FocusListener} is
   *        created for.
   *
   * @return A new {@link FocusListener}.
   */
  protected FocusListener createFocusListener(JSlider slider)
  {
    return new FocusHandler();
  }

  /**
   * Creates a new {@link ScrollListener}.
   *
   * @param slider The {@link JSlider} that this {@link ScrollListener} is
   *        created for.
   *
   * @return A new {@link ScrollListener}.
   */
  protected ScrollListener createScrollListener(JSlider slider)
  {
    return new ScrollListener();
  }

  /**
   * Creates a new {@link PropertyChangeListener}.
   *
   * @param slider The {@link JSlider} that this {@link
   *        PropertyChangeListener} is created for.
   *
   * @return A new {@link PropertyChangeListener}.
   */
  protected PropertyChangeListener createPropertyChangeListener(JSlider slider)
  {
    return new PropertyChangeHandler();
  }

  /**
   * Creates and registers all the listeners for this UI delegate. This
   * includes creating the ScrollListener and registering it to the timer.
   *
   * @param slider The {@link JSlider} is having listeners installed.
   */
  protected void installListeners(JSlider slider)
  {
    propertyChangeListener = createPropertyChangeListener(slider);
    componentListener = createComponentListener(slider);
    trackListener = createTrackListener(slider);
    focusListener = createFocusListener(slider);
    changeListener = createChangeListener(slider);
    scrollListener = createScrollListener(slider);

    slider.addPropertyChangeListener(propertyChangeListener);
    slider.addComponentListener(componentListener);
    slider.addMouseListener(trackListener);
    slider.addMouseMotionListener(trackListener);
    slider.addFocusListener(focusListener);
    slider.getModel().addChangeListener(changeListener);

    scrollTimer.addActionListener(scrollListener);
  }

  /**
   * Unregisters all the listeners that this UI delegate was using. In
   * addition, it will also null any listeners that it was using.
   *
   * @param slider The {@link JSlider} that is having listeners removed.
   */
  protected void uninstallListeners(JSlider slider)
  {
    slider.removePropertyChangeListener(propertyChangeListener);
    slider.removeComponentListener(componentListener);
    slider.removeMouseListener(trackListener);
    slider.removeMouseMotionListener(trackListener);
    slider.removeFocusListener(focusListener);
    slider.getModel().removeChangeListener(changeListener);

    scrollTimer.removeActionListener(scrollListener);

    propertyChangeListener = null;
    componentListener = null;
    trackListener = null;
    focusListener = null;
    changeListener = null;
    scrollListener = null;
  }

  /**
   * Installs any keyboard actions. The list of keys that need to be bound are
   * listed in Basic look and feel's defaults.
   *
   * @param slider The {@link JSlider} that is having keyboard actions
   *        installed.
   */
  protected void installKeyboardActions(JSlider slider)
  {
    InputMap keyMap = getInputMap(JComponent.WHEN_FOCUSED);
    SwingUtilities.replaceUIInputMap(slider, JComponent.WHEN_FOCUSED, keyMap);
    ActionMap map = getActionMap();
    SwingUtilities.replaceUIActionMap(slider, map);
  }

  /**
   * Uninstalls any keyboard actions. The list of keys used  are listed in
   * Basic look and feel's defaults.
   *
   * @param slider The {@link JSlider} that is having keyboard actions
   *        uninstalled.
   */
  protected void uninstallKeyboardActions(JSlider slider)
  {
    SwingUtilities.replaceUIActionMap(slider, null);
    SwingUtilities.replaceUIInputMap(slider, JComponent.WHEN_FOCUSED, null);
  }

  /* XXX: This is all after experimentation with SUN's implementation.

     PreferredHorizontalSize seems to be 200x21.
     PreferredVerticalSize seems to be 21x200.

     MinimumHorizontalSize seems to be 36x21.
     MinimumVerticalSize seems to be 21x36.

     PreferredSize seems to be 200x63. Or Components.getBounds?

     MinimumSize seems to be 36x63.

     MaximumSize seems to be 32767x63.
   */

  /**
   * This method returns the preferred size when the slider is horizontally
   * oriented.
   *
   * @return The dimensions of the preferred horizontal size.
   */
  public Dimension getPreferredHorizontalSize()
  {
    Dimension dim = UIManager.getDimension("Slider.horizontalSize");
    if (dim == null) // Just to be sure we mirror the default.
      dim = new Dimension(200, 21);
    return dim;
  }

  /**
   * This method returns the preferred size when the slider is vertically
   * oriented.
   *
   * @return The dimensions of the preferred vertical size.
   */
  public Dimension getPreferredVerticalSize()
  {
    Dimension dim = UIManager.getDimension("Slider.verticalSize");
    if (dim == null) // Just to be sure we mirror the default.
      dim = new Dimension(21, 200);
    return dim;
  }

  /**
   * This method returns the minimum size when the slider is horizontally
   * oriented.
   *
   * @return The dimensions of the minimum horizontal size.
   */
  public Dimension getMinimumHorizontalSize()
  {
    Dimension dim = UIManager.getDimension("Slider.minimumHorizontalSize");
    if (dim == null) // Just to be sure we mirror the default.
      dim = new Dimension(36, 21);
    return dim;
  }

  /**
   * This method returns the minimum size of the slider when it  is vertically
   * oriented.
   *
   * @return The dimensions of the minimum vertical size.
   */
  public Dimension getMinimumVerticalSize()
  {
    Dimension dim = UIManager.getDimension("Slider.minimumVerticalSize");
    if (dim == null) // Just to be sure we mirror the default.
      dim = new Dimension(21, 36);
    return dim;
  }

  /**
   * This method returns the preferred size of the component. If it returns
   * null, then it is up to the Layout Manager to give the {@link JComponent}
   * a size.
   *
   * @param c The {@link JComponent} to find the preferred size for.
   *
   * @return The dimensions of the preferred size.
   */
  public Dimension getPreferredSize(JComponent c)
  {
    recalculateIfInsetsChanged();
    Dimension dim;
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        // Create copy here to protect the UIManager value.
        dim = new Dimension(getPreferredHorizontalSize());
        dim.height = insetCache.top + insetCache.bottom;
        dim.height += focusInsets.top + focusInsets.bottom;
        dim.height += trackRect.height + tickRect.height + labelRect.height;
      }
    else
      {
        // Create copy here to protect the UIManager value.
        dim = new Dimension(getPreferredVerticalSize());
        dim.width = insetCache.left + insetCache.right;
        dim.width += focusInsets.left + focusInsets.right;
        dim.width += trackRect.width + tickRect.width + labelRect.width;
      }
    return dim;
  }

  /**
   * This method returns the minimum size for this {@link JSlider}  for this
   * look and feel. If it returns null, then it is up to the Layout Manager
   * to give the {@link JComponent} a size.
   *
   * @param c The {@link JComponent} to find the minimum size for.
   *
   * @return The dimensions of the minimum size.
   */
  public Dimension getMinimumSize(JComponent c)
  {
    recalculateIfInsetsChanged();
    Dimension dim;
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        // Create copy here to protect the UIManager value.
        dim = new Dimension(getMinimumHorizontalSize());
        dim.height = insetCache.top + insetCache.bottom;
        dim.height += focusInsets.top + focusInsets.bottom;
        dim.height += trackRect.height + tickRect.height + labelRect.height;
      }
    else
      {
        // Create copy here to protect the UIManager value.
        dim = new Dimension(getMinimumVerticalSize());
        dim.width = insetCache.left + insetCache.right;
        dim.width += focusInsets.left + focusInsets.right;
        dim.width += trackRect.width + tickRect.width + labelRect.width;
      }
    return dim;
  }

  /**
   * This method returns the maximum size for this {@link JSlider} for this
   * look and feel.
   *
   * @param c The {@link JComponent} to find a maximum size for.
   *
   * @return The dimensions of the maximum size.
   */
  public Dimension getMaximumSize(JComponent c)
  {
    Dimension dim = getPreferredSize(c);
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      dim.width = Short.MAX_VALUE;
    else
      dim.height = Short.MAX_VALUE;
    return dim;
  }

  /**
   * This method calculates all the sizes of the rectangles by delegating to
   * the helper methods calculateXXXRect.
   */
  protected void calculateGeometry()
  {
    calculateFocusRect();
    calculateContentRect();
    calculateThumbSize();
    calculateTrackBuffer();
    calculateTrackRect();
    calculateTickRect();
    calculateLabelRect();
    calculateThumbLocation();
  }

  /**
   * This method calculates the size and position of the focusRect. This
   * method does not need to be called if the orientation changes.
   */
  protected void calculateFocusRect()
  {
    focusRect.x = insetCache.left;
    focusRect.y = insetCache.top;
    focusRect.width = slider.getWidth() - insetCache.left - insetCache.right;
    focusRect.height = slider.getHeight() - insetCache.top - insetCache.bottom;
  }

  /**
   * Sets the width and height of the <code>thumbRect</code> field, using the
   * dimensions returned by {@link #getThumbSize()}.
   */
  protected void calculateThumbSize()
  {
    Dimension d = getThumbSize();
    thumbRect.width = d.width;
    thumbRect.height = d.height;
  }

  /**
   * Updates the <code>contentRect</code> field to an area inside the 
   * <code>focusRect</code>. This method does not need to be called if the 
   * orientation changes.
   */
  protected void calculateContentRect()
  {
    contentRect.x = focusRect.x + focusInsets.left;
    contentRect.y = focusRect.y + focusInsets.top;
    
    contentRect.width = focusRect.width - focusInsets.left - focusInsets.right;
    contentRect.height = focusRect.height - focusInsets.top
                         - focusInsets.bottom;
  }

  /**
   * Calculates the position of the thumbRect based on the current value of
   * the slider. It must take into  account the orientation of the slider.
   */
  protected void calculateThumbLocation()
  {
    int value = slider.getValue();

    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        thumbRect.x = xPositionForValue(value) - thumbRect.width / 2;
        thumbRect.y = trackRect.y + 1;
      }
    else
      {
        thumbRect.x = trackRect.x + 1;
        thumbRect.y = yPositionForValue(value) - thumbRect.height / 2;
      }
  }

  /**
   * Calculates the gap size between the edge of the <code>contentRect</code> 
   * and the edge of the <code>trackRect</code>, storing the result in the
   * <code>trackBuffer</code> field.  Sufficient space needs to be reserved 
   * for the slider thumb and/or the labels at each end of the slider track.
   */
  protected void calculateTrackBuffer()
  {
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        int w = Math.max(getWidthOfLowValueLabel(), getWidthOfHighValueLabel());
        trackBuffer = Math.max(thumbRect.width / 2, w / 2);
        
      }
    else
      {
        int h = Math.max(getHeightOfLowValueLabel(), 
                         getHeightOfHighValueLabel());
        trackBuffer = Math.max(thumbRect.height / 2, h / 2);
      }
  }

  /**
   * Returns the size of the slider's thumb.  The size is hard coded to
   * <code>11 x 20</code> for horizontal sliders, and <code>20 x 11</code> for 
   * vertical sliders. Note that a new instance of {@link Dimension} is 
   * returned for every call to this method (this seems wasteful, but 
   * {@link Dimension} instances are not immutable, so this is probably 
   * unavoidable).
   *
   * @return The size of the slider's thumb.
   */
  protected Dimension getThumbSize()
  {
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      return new Dimension(11, 20);
    else
      return new Dimension(20, 11);
  }

  /**
   * Calculates the size and position of the trackRect. It must take into
   * account the orientation of the slider.
   */
  protected void calculateTrackRect()
  {
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        int center = thumbRect.height;
        if (slider.getPaintTicks())
          center += getTickLength();
        if (slider.getPaintLabels())
          center += getHeightOfTallestLabel();
        trackRect.x = contentRect.x + trackBuffer;
        trackRect.y = contentRect.y + (contentRect.height - center - 1) / 2;
        trackRect.width = contentRect.width - 2 * trackBuffer;
        trackRect.height = thumbRect.height;
      }
    else
      {
        int center = thumbRect.width;
        if (slider.getPaintTicks())
          center += getTickLength();
        if (slider.getPaintLabels())
          center += getWidthOfWidestLabel();
        trackRect.x = contentRect.x + (contentRect.width - center - 1) / 2;
        trackRect.y = contentRect.y + trackBuffer;
        trackRect.width = thumbRect.width;
        trackRect.height = contentRect.height - 2 * trackBuffer;
      }
  }

  /**
   * This method returns the height of the tick area box if the slider  is
   * horizontal and the width of the tick area box is the slider is vertical.
   * It not necessarily how long the ticks will be. If a gap between the edge
   * of tick box and the actual tick is desired, then that will need to be
   * handled in the tick painting methods.
   *
   * @return The height (or width if the slider is vertical) of the tick
   *         rectangle.
   */
  protected int getTickLength()
  {
    return 8;
  }

  /**
   * This method calculates the size and position of the tickRect. It must
   * take into account the orientation of the slider.
   */
  protected void calculateTickRect()
  {
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        tickRect.x = trackRect.x;
        tickRect.y = trackRect.y + trackRect.height;
        tickRect.width = trackRect.width;
        tickRect.height = getTickLength();
        
        // this makes our Mauve tests pass...can't explain it!
        if (!slider.getPaintTicks())
          {
            tickRect.y--;
            tickRect.height = 0;
          }
      }
    else
      {
        tickRect.x = trackRect.x + trackRect.width;
        tickRect.y = trackRect.y;
        tickRect.width = getTickLength();
        tickRect.height = trackRect.height;

        // this makes our Mauve tests pass...can't explain it!
        if (!slider.getPaintTicks())
          {
            tickRect.x--;
            tickRect.width = 0;
          }
      }
  }

  /**
   * Calculates the <code>labelRect</code> field, taking into account the 
   * orientation of the slider.
   */
  protected void calculateLabelRect()
  {
    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        if (slider.getPaintLabels())
          {
            labelRect.x = tickRect.x - trackBuffer;
            labelRect.y = tickRect.y + tickRect.height;
            labelRect.width = tickRect.width + trackBuffer * 2;
            labelRect.height = getHeightOfTallestLabel();
          }
        else
          {
            labelRect.x = tickRect.x;
            labelRect.y = tickRect.y + tickRect.height;
            labelRect.width = tickRect.width;
            labelRect.height = 0;
          }
      }
    else
      {
        if (slider.getPaintLabels())
          {
            labelRect.x = tickRect.x + tickRect.width;
            labelRect.y = tickRect.y - trackBuffer;
            labelRect.width = getWidthOfWidestLabel();
            labelRect.height = tickRect.height + trackBuffer * 2;
          }
        else
          {
            labelRect.x = tickRect.x + tickRect.width;
            labelRect.y = tickRect.y;
            labelRect.width = 0;
            labelRect.height = tickRect.height;
          }
      }
  }

  /**
   * This method returns the width of the widest label  in the slider's label
   * table.
   *
   * @return The width of the widest label or 0 if no label table exists.
   */
  protected int getWidthOfWidestLabel()
  {
    int widest = 0;
    Dictionary table = slider.getLabelTable();
    if (table != null)
      {
        for (Enumeration list = slider.getLabelTable().elements();
             list.hasMoreElements();)
          {
            Component label = (Component) list.nextElement();
            widest = Math.max(label.getPreferredSize().width, widest);
          }
      }
    return widest;
  }

  /**
   * This method returns the height of the tallest label in the slider's label
   * table.
   *
   * @return The height of the tallest label or 0 if no label table exists.
   */
  protected int getHeightOfTallestLabel()
  {
    int tallest = 0;
    Component label;

    if (slider.getLabelTable() == null)
      return 0;
    Dimension pref;
    for (Enumeration list = slider.getLabelTable().elements();
         list.hasMoreElements();)
      {
        Object comp = list.nextElement();
        if (! (comp instanceof Component))
          continue;
        label = (Component) comp;
        pref = label.getPreferredSize();
        if (pref != null && pref.height > tallest)
          tallest = pref.height;
      }
    return tallest;
  }

  /**
   * Returns the width of the label whose key has the highest value, or 0 if
   * there are no labels.
   *
   * @return The width of the label whose key has the highest value.
   * 
   * @see #getHighestValueLabel()
   */
  protected int getWidthOfHighValueLabel()
  {
    Component highValueLabel = getHighestValueLabel();
    if (highValueLabel != null)
      return highValueLabel.getPreferredSize().width;
    else
      return 0;
  }

  /**
   * Returns the width of the label whose key has the lowest value, or 0 if
   * there are no labels.
   *
   * @return The width of the label whose key has the lowest value.
   * 
   * @see #getLowestValueLabel()
   */
  protected int getWidthOfLowValueLabel()
  {
    Component lowValueLabel = getLowestValueLabel();
    if (lowValueLabel != null)
      return lowValueLabel.getPreferredSize().width;
    else
      return 0;
  }

  /**
   * Returns the height of the label whose key has the highest value, or 0 if
   * there are no labels.
   *
   * @return The height of the high value label or 0 if no label table exists.
   */
  protected int getHeightOfHighValueLabel()
  {
    Component highValueLabel = getHighestValueLabel();
    if (highValueLabel != null)
      return highValueLabel.getPreferredSize().height;
    else
      return 0;
  }

  /**
   * Returns the height of the label whose key has the lowest value, or 0 if
   * there are no labels.
   *
   * @return The height of the low value label or 0 if no label table exists.
   */
  protected int getHeightOfLowValueLabel()
  {
    Component lowValueLabel = getLowestValueLabel();
    if (lowValueLabel != null)
      return lowValueLabel.getPreferredSize().height;
    else
      return 0;
  }

  /**
   * Returns <code>true</code> if the slider scale is to be drawn inverted,
   * and <code>false</code> if not.
   *
   * @return <code>true</code> if the slider is to be drawn inverted.
   */
  protected boolean drawInverted()
  {
    return slider.getInverted();
  }

  /**
   * This method returns the label whose key has the lowest value.
   *
   * @return The low value label or null if no label table exists.
   */
  protected Component getLowestValueLabel()
  {
    Integer key = new Integer(Integer.MAX_VALUE);
    Integer tmpKey;
    Dictionary labelTable = slider.getLabelTable();

    if (labelTable == null)
      return null;

    for (Enumeration list = labelTable.keys(); list.hasMoreElements();)
      {
        Object value = list.nextElement();
        if (! (value instanceof Integer))
          continue;
        tmpKey = (Integer) value;
        if (tmpKey.intValue() < key.intValue())
          key = tmpKey;
      }
    Object comp = labelTable.get(key);
    if (! (comp instanceof Component))
      return null;
    return (Component) comp;
  }

  /**
   * Returns the label whose key has the highest value.
   *
   * @return The label whose key has the highest value or <code>null</code> if 
   *     no label table exists.
   */
  protected Component getHighestValueLabel()
  {
    Integer key = new Integer(Integer.MIN_VALUE);
    Integer tmpKey;
    Dictionary labelTable = slider.getLabelTable();

    if (labelTable == null)
      return null;

    for (Enumeration list = labelTable.keys(); list.hasMoreElements();)
      {
        Object value = list.nextElement();
        if (! (value instanceof Integer))
          continue;
        tmpKey = (Integer) value;
        if (tmpKey.intValue() > key.intValue())
          key = tmpKey;
      }
    Object comp = labelTable.get(key);
    if (! (comp instanceof Component))
      return null;
    return (Component) comp;
  }

  /**
   * This method is used to paint the {@link JSlider}. It delegates all its
   * duties to the various paint methods like paintTicks(),  paintTrack(),
   * paintThumb(), etc.
   *
   * @param g The {@link Graphics} object to paint with.
   * @param c The {@link JComponent} that is being painted.
   */
  public void paint(Graphics g, JComponent c)
  {
    recalculateIfInsetsChanged();
    recalculateIfOrientationChanged();
    if (slider.getPaintTrack() && hitClip(g, trackRect))
      paintTrack(g);
    if (slider.getPaintTicks() && hitClip(g, tickRect))
      paintTicks(g);
    if (slider.getPaintLabels() && hitClip(g, labelRect))
      paintLabels(g);
    if (slider.hasFocus() && hitClip(g, focusRect))
      paintFocus(g);
    if (hitClip(g, thumbRect))
      paintThumb(g);
  }

  /**
   * This method recalculates any rectangles that need to be recalculated
   * after the insets of the component have changed.
   */
  protected void recalculateIfInsetsChanged()
  {
    Insets insets = slider.getInsets();
    if (! insets.equals(insetCache))
      {
        insetCache = insets;
        calculateGeometry();
      }
  }

  /**
   * This method recalculates any rectangles that need to be recalculated
   * after the orientation of the slider changes.
   */
  protected void recalculateIfOrientationChanged()
  {
    // Examining a test program shows that either Sun calls private
    // methods that we don't know about, or these don't do anything.  
    calculateThumbSize();
    calculateTrackBuffer();
    calculateTrackRect();
    calculateThumbLocation();

    calculateTickRect();
    calculateLabelRect();
  }

  /**
   * This method is called during a repaint if the slider has focus. It draws
   * an outline of the  focusRect using the color returned by
   * getFocusColor().
   *
   * @param g The {@link Graphics} object to draw with.
   */
  public void paintFocus(Graphics g)
  {
    Color saved_color = g.getColor();

    g.setColor(getFocusColor());
    
    g.drawRect(focusRect.x, focusRect.y, focusRect.width, focusRect.height);

    g.setColor(saved_color);
  }

  /**
   * <p>
   * This method is called during a repaint if the  track is to be drawn. It
   * draws a 3D rectangle to  represent the track. The track is not the size
   * of the trackRect. The top and left edges of the track should be outlined
   * with the shadow color. The bottom and right edges should be outlined
   * with the highlight color.
   * </p>
   * <pre>
   *    a---d   
   *    |   |   
   *    |   |   a------------------------d
   *    |   |   |                        |
   *    |   |   b------------------------c
   *    |   |
   *    |   |   
   *    b---c
   * </pre>
   * 
   * <p>
   * The b-a-d path needs to be drawn with the shadow color and the b-c-d path
   * needs to be drawn with the highlight color.
   * </p>
   *
   * @param g The {@link Graphics} object to draw with.
   */
  public void paintTrack(Graphics g)
  {
    Color saved_color = g.getColor();
    int width;
    int height;

    Point a = new Point(trackRect.x, trackRect.y + 1);
    Point b = new Point(a);
    Point c = new Point(a);
    Point d = new Point(a);

    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        width = trackRect.width;
        height = (thumbRect.height / 4 == 0) ? 1 : thumbRect.height / 4;

        a.translate(0, (trackRect.height / 2) - (height / 2));
        b.translate(0, (trackRect.height / 2) + (height / 2));
        c.translate(trackRect.width, (trackRect.height / 2) + (height / 2));
        d.translate(trackRect.width, (trackRect.height / 2) - (height / 2));
      }
    else
      {
        width = (thumbRect.width / 4 == 0) ? 1 : thumbRect.width / 4;
        height = trackRect.height;

        a.translate((trackRect.width / 2) - (width / 2), 0);
        b.translate((trackRect.width / 2) - (width / 2), trackRect.height);
        c.translate((trackRect.width / 2) + (width / 2), trackRect.height);
        d.translate((trackRect.width / 2) + (width / 2), 0);
      }
    g.setColor(Color.GRAY);
    g.fillRect(a.x, a.y, width, height);

    g.setColor(getHighlightColor());
    g.drawLine(b.x, b.y, c.x, c.y);
    g.drawLine(c.x, c.y, d.x, d.y);

    g.setColor(getShadowColor());
    g.drawLine(b.x, b.y, a.x, a.y);
    g.drawLine(a.x, a.y, d.x, d.y);

    g.setColor(saved_color);
  }

  /**
   * This method is called during a repaint if the ticks are to be drawn. This
   * method must still verify that the majorTickSpacing and minorTickSpacing
   * are greater than zero before drawing the ticks.
   *
   * @param g The {@link Graphics} object to draw with.
   */
  public void paintTicks(Graphics g)
  {
    int max = slider.getMaximum();
    int min = slider.getMinimum();
    int majorSpace = slider.getMajorTickSpacing();
    int minorSpace = slider.getMinorTickSpacing();

    if (majorSpace > 0)
      {
        if (slider.getOrientation() == JSlider.HORIZONTAL)
          {
            g.translate(0, tickRect.y);
            for (int i = min; i <= max; i += majorSpace)
              paintMajorTickForHorizSlider(g, tickRect, xPositionForValue(i));
            g.translate(0, -tickRect.y);
          }
        else // JSlider.VERTICAL
          {
            g.translate(tickRect.x, 0);
            for (int i = min; i <= max; i += majorSpace)
              paintMajorTickForVertSlider(g, tickRect, yPositionForValue(i));
            g.translate(-tickRect.x, 0);
          }
      }
    if (minorSpace > 0)
      {
        if (slider.getOrientation() == JSlider.HORIZONTAL)
          {
            g.translate(0, tickRect.y);
            for (int i = min; i <= max; i += minorSpace)
              paintMinorTickForHorizSlider(g, tickRect, xPositionForValue(i));
            g.translate(0, -tickRect.y);
          }
        else
          {
            g.translate(tickRect.x, 0);
            for (int i = min; i <= max; i += minorSpace)
              paintMinorTickForVertSlider(g, tickRect, yPositionForValue(i));
            g.translate(-tickRect.x, 0);
          }
      }
  }

  /* Minor ticks start at 1/4 of the height (or width) of the tickRect and 
     extend to 1/2 of the tickRect.

     Major ticks start at 1/4 of the height and extend to 3/4.
   */

  /**
   * This method paints a minor tick for a horizontal slider at the given x
   * value. x represents the x coordinate to paint at.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param tickBounds The tickRect rectangle.
   * @param x The x coordinate to draw the tick at.
   */
  protected void paintMinorTickForHorizSlider(Graphics g,
                                              Rectangle tickBounds, int x)
  {
    int y = tickRect.height / 4;
    Color saved = g.getColor();
    g.setColor(Color.BLACK);

    g.drawLine(x, y, x, y + tickRect.height / 4);
    g.setColor(saved);
  }

  /**
   * This method paints a major tick for a horizontal slider at the given x
   * value. x represents the x coordinate to paint at.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param tickBounds The tickRect rectangle.
   * @param x The x coordinate to draw the tick at.
   */
  protected void paintMajorTickForHorizSlider(Graphics g,
                                              Rectangle tickBounds, int x)
  {
    int y = tickRect.height / 4;
    Color saved = g.getColor();
    g.setColor(Color.BLACK);

    g.drawLine(x, y, x, y + tickRect.height / 2);
    g.setColor(saved);
  }

  /**
   * This method paints a minor tick for a vertical slider at the given y
   * value. y represents the y coordinate to paint at.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param tickBounds The tickRect rectangle.
   * @param y The y coordinate to draw the tick at.
   */
  protected void paintMinorTickForVertSlider(Graphics g, Rectangle tickBounds,
                                             int y)
  {
    int x = tickRect.width / 4;
    Color saved = g.getColor();
    g.setColor(Color.BLACK);

    g.drawLine(x, y, x + tickRect.width / 4, y);
    g.setColor(saved);
  }

  /**
   * This method paints a major tick for a vertical slider at the given y
   * value. y represents the y coordinate to paint at.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param tickBounds The tickRect rectangle.
   * @param y The y coordinate to draw the tick at.
   */
  protected void paintMajorTickForVertSlider(Graphics g, Rectangle tickBounds,
                                             int y)
  {
    int x = tickRect.width / 4;
    Color saved = g.getColor();
    g.setColor(Color.BLACK);

    g.drawLine(x, y, x + tickRect.width / 2, y);
    g.setColor(saved);
  }

  /**
   * This method paints all the labels from the slider's label table. This
   * method must make sure that the label table is not null before painting
   * the labels. Each entry in the label table is a (integer, component)
   * pair. Every label is painted at the value of the integer.
   *
   * @param g The {@link Graphics} object to draw with.
   */
  public void paintLabels(Graphics g)
  {
    Dictionary table = slider.getLabelTable();
    if (table != null)
      {
        int min = slider.getMinimum();
        int max = slider.getMaximum();
        for (Enumeration list = table.keys(); list.hasMoreElements();)
          {
            Integer key = (Integer) list.nextElement();
            int value = key.intValue();
            if (value >= min && value <= max)
              {
                Component label = (Component) table.get(key);
                if (slider.getOrientation() == JSlider.HORIZONTAL)
                  {
                    g.translate(0, labelRect.y);
                    paintHorizontalLabel(g, value, label);
                    g.translate(0, -labelRect.y);
                  }
                else
                  {
                    g.translate(labelRect.x, 0);
                    paintVerticalLabel(g, value, label);
                    g.translate(-labelRect.x, 0);
                  }
              }
          }
      }
  }

  /**
   * This method paints the label on the horizontal slider at the value
   * specified. The value is not a coordinate. It is a value within the range
   * of the  slider. If the value is not within the range of the slider, this
   * method will do nothing. This method should not paint outside the
   * boundaries of the labelRect.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param value The value to paint at.
   * @param label The label to paint.
   */
  protected void paintHorizontalLabel(Graphics g, int value, Component label)
  {
    int center = xPositionForValue(value);
    int left = center - label.getPreferredSize().width / 2;
    g.translate(left, 0);
    label.paint(g);
    g.translate(-left, 0);
  }

  /**
   * This method paints the label on the vertical slider at the value
   * specified. The value is not a coordinate. It is a value within the range
   * of the  slider. If the value is not within the range of the slider, this
   * method will do nothing. This method should not paint outside the
   * boundaries of the labelRect.
   *
   * @param g The {@link Graphics} object to draw with.
   * @param value The value to paint at.
   * @param label The label to paint.
   */
  protected void paintVerticalLabel(Graphics g, int value, Component label)
  {
    int center = yPositionForValue(value);
    int top = center - label.getPreferredSize().height / 2;
    g.translate(0, top);
    label.paint(g);
    g.translate(0, -top);
  }

  /**
   * <p>
   * This method paints a thumb. There are two types of thumb:
   * </p>
   * <pre>
   *   Vertical         Horizontal
   *    a---b            a-----b
   *    |   |            |      \
   *    e   c            |       c
   *     \ /             |      /
   *      d              e-----d
   *  </pre>
   * 
   * <p>
   * In the case of vertical thumbs, we highlight the path b-a-e-d and shadow
   * the path b-c-d. In the case of horizontal thumbs, we highlight the path
   * c-b-a-e and shadow the path c-d-e. In both cases we fill the path
   * a-b-c-d-e before shadows and highlights are drawn.
   * </p>
   *
   * @param g The graphics object to paint with
   */
  public void paintThumb(Graphics g)
  {
    Color saved_color = g.getColor();

    Point a = new Point(thumbRect.x, thumbRect.y);
    Point b = new Point(a);
    Point c = new Point(a);
    Point d = new Point(a);
    Point e = new Point(a);

    Polygon bright;
    Polygon light; // light shadow
    Polygon dark; // dark shadow
    Polygon all;

    // This will be in X-dimension if the slider is inverted and y if it isn't.
    int turnPoint;

    if (slider.getOrientation() == JSlider.HORIZONTAL)
      {
        turnPoint = thumbRect.height * 3 / 4;

        b.translate(thumbRect.width - 1, 0);
        c.translate(thumbRect.width - 1, turnPoint);
        d.translate(thumbRect.width / 2 - 1, thumbRect.height - 1);
        e.translate(0, turnPoint);

        bright = new Polygon(new int[] { b.x - 1, a.x, e.x, d.x },
                             new int[] { b.y, a.y, e.y, d.y }, 4);

        dark = new Polygon(new int[] { b.x, c.x, d.x + 1 }, new int[] { b.y,
                                                                       c.y - 1,
                                                                       d.y }, 3);

        light = new Polygon(new int[] { b.x - 1, c.x - 1, d.x + 1 },
                            new int[] { b.y + 1, c.y - 1, d.y - 1 }, 3);

        all = new Polygon(
                          new int[] { a.x + 1, b.x - 2, c.x - 2, d.x, e.x + 1 },
                          new int[] { a.y + 1, b.y + 1, c.y - 1, d.y - 1, e.y },
                          5);
      }
    else
      {
        turnPoint = thumbRect.width * 3 / 4 - 1;

        b.translate(turnPoint, 0);
        c.translate(thumbRect.width - 1, thumbRect.height / 2);
        d.translate(turnPoint, thumbRect.height - 1);
        e.translate(0, thumbRect.height - 1);

        bright = new Polygon(new int[] { c.x - 1, b.x, a.x, e.x },
                             new int[] { c.y - 1, b.y, a.y, e.y - 1 }, 4);

        dark = new Polygon(new int[] { c.x, d.x, e.x }, new int[] { c.y, d.y,
                                                                   e.y }, 3);

        light = new Polygon(new int[] { c.x - 1, d.x, e.x + 1 },
                            new int[] { c.y, d.y - 1, e.y - 1 }, 3);
        all = new Polygon(new int[] { a.x + 1, b.x, c.x - 2, c.x - 2, d.x,
                                     e.x + 1 }, new int[] { a.y + 1, b.y + 1,
                                                           c.y - 1, c.y,
                                                           d.y - 2, e.y - 2 },
                          6);
      }

    g.setColor(Color.WHITE);
    g.drawPolyline(bright.xpoints, bright.ypoints, bright.npoints);

    g.setColor(Color.BLACK);
    g.drawPolyline(dark.xpoints, dark.ypoints, dark.npoints);

    g.setColor(Color.GRAY);
    g.drawPolyline(light.xpoints, light.ypoints, light.npoints);

    g.setColor(Color.LIGHT_GRAY);
    g.drawPolyline(all.xpoints, all.ypoints, all.npoints);
    g.fillPolygon(all);

    g.setColor(saved_color);
  }

  /**
   * This method sets the position of the thumbRect.
   *
   * @param x The new x position.
   * @param y The new y position.
   */
  public void setThumbLocation(int x, int y)
  {
    Rectangle union = new Rectangle(thumbRect);
    thumbRect.setLocation(x, y);
    SwingUtilities.computeUnion(thumbRect.x, thumbRect.y, thumbRect.width,
                                thumbRect.height, union);
    slider.repaint(union);
  }

  /**
   * Moves the thumb one block in the direction specified (a block is 1/10th
   * of the slider range).   If the slider snaps to ticks, this method is 
   * responsible for snapping it to a tick after the thumb has been moved.
   *
   * @param direction  the direction (positive values increment the thumb 
   *   position by one block, zero/negative values decrement the thumb position
   *   by one block).
   */
  public void scrollByBlock(int direction)
  {
    int unit = (slider.getMaximum() - slider.getMinimum()) / 10;
    int moveTo = slider.getValue();
    if (direction > 0)
      moveTo += unit;
    else
      moveTo -= unit;

    if (slider.getSnapToTicks())
      moveTo = findClosestTick(moveTo);

    slider.setValue(moveTo);
  }

  /**
   * Moves the thumb one unit in the specified direction. If the slider snaps 
   * to ticks, this method is responsible for snapping it to a tick after the 
   * thumb has been moved.
   *
   * @param direction  the direction (positive values increment the thumb 
   *   position by one, zero/negative values decrement the thumb position by
   *   one).
   */
  public void scrollByUnit(int direction)
  {
    int moveTo = slider.getValue();
    if (direction > 0)
      moveTo++;
    else
      moveTo--;

    if (slider.getSnapToTicks())
      moveTo = findClosestTick(moveTo);

    slider.setValue(moveTo);
  }

  /**
   * This method is called when there has been a click in the track and the
   * thumb needs to be scrolled  on regular intervals. This method is only
   * responsible  for starting the timer and not for stopping it.
   *
   * @param dir The direction to move in.
   */
  protected void scrollDueToClickInTrack(int dir)
  {
    scrollTimer.stop();

    scrollListener.setDirection(dir);
    scrollListener.setScrollByBlock(true);

    scrollTimer.start();
  }

  /**
   * Returns the x-coordinate (relative to the component) for the given slider 
   * value.  This method assumes that the <code>trackRect</code> field is
   * set up.
   *
   * @param value  the slider value.
   *
   * @return The x-coordinate.
   */
  protected int xPositionForValue(int value)
  {
    int min = slider.getMinimum();
    int max = slider.getMaximum();
    int len = trackRect.width;
    double range = max - min;
    double pixPerVal = len / range;
    int left = trackRect.x;
    int right = left + trackRect.width - 1;
    int xpos;
    if (! drawInverted())
      xpos = left + (int) Math.round(pixPerVal * ((double) value - min));
    else
      xpos = right - (int) Math.round(pixPerVal * ((double) value - min));
    xpos = Math.max(left, xpos);
    xpos = Math.min(right, xpos);
    return xpos;
  }

  /**
   * Returns the y-coordinate (relative to the component) for the given slider 
   * value.  This method assumes that the <code>trackRect</code> field is 
   * set up.
   *
   * @param value  the slider value.
   *
   * @return The y-coordinate.
   */
  protected int yPositionForValue(int value)
  {
    int min = slider.getMinimum();
    int max = slider.getMaximum();
    int len = trackRect.height;
    double range = max - min;
    double pixPerVal = len / range;
    int top = trackRect.y;
    int bottom = top + trackRect.height - 1;
    int ypos;
    if (! drawInverted())
      ypos = top + (int) Math.round(pixPerVal * ((double) max - value));
    else
      ypos = top + (int) Math.round(pixPerVal * ((double) value - min));
    ypos = Math.max(top, ypos);
    ypos = Math.min(bottom, ypos);
    return ypos;
  }

  /**
   * This method returns the value in the slider's range given the y
   * coordinate. If the value is out of range, it will  return the closest
   * legal value.
   *
   * @param yPos The y coordinate to calculate a value for.
   *
   * @return The value for the y coordinate.
   */
  public int valueForYPosition(int yPos)
  {
    int min = slider.getMinimum();
    int max = slider.getMaximum();
    int len = trackRect.height;

    int value;

    // If the length is 0, you shouldn't be able to even see where the slider 
    // is.  This really shouldn't ever happen, but just in case, we'll return 
    // the middle.
    if (len == 0)
      return (max - min) / 2;

    if (! drawInverted())
      value = (len - (yPos - trackRect.y)) * (max - min) / len + min;
    else
      value = (yPos - trackRect.y) * (max - min) / len + min;

    // If this isn't a legal value, then we'll have to move to one now.
    if (value > max)
      value = max;
    else if (value < min)
      value = min;
    return value;
  }

  /**
   * This method returns the value in the slider's range given the x
   * coordinate. If the value is out of range, it will return the closest
   * legal value.
   *
   * @param xPos The x coordinate to calculate a value for.
   *
   * @return The value for the x coordinate.
   */
  public int valueForXPosition(int xPos)
  {
    int min = slider.getMinimum();
    int max = slider.getMaximum();
    int len = trackRect.width;

    int value;

    // If the length is 0, you shouldn't be able to even see where the slider 
    // is.  This really shouldn't ever happen, but just in case, we'll return 
    // the middle.
    if (len == 0)
      return (max - min) / 2;

    if (! drawInverted())
      value = (xPos - trackRect.x) * (max - min) / len + min;
    else
      value = (len - (xPos - trackRect.x)) * (max - min) / len + min;

    // If this isn't a legal value, then we'll have to move to one now.
    if (value > max)
      value = max;
    else if (value < min)
      value = min;
    return value;
  }

  /**
   * This method finds the closest value that has a tick associated with it.
   * This is package-private to avoid an accessor method.
   *
   * @param value The value to search from.
   *
   * @return The closest value that has a tick associated with it.
   */
  int findClosestTick(int value)
  {
    int min = slider.getMinimum();
    int max = slider.getMaximum();
    int majorSpace = slider.getMajorTickSpacing();
    int minorSpace = slider.getMinorTickSpacing();

    // The default value to return is value + minor or
    // value + major. 
    // Initializing at min - value leaves us with a default
    // return value of min, which always has tick marks
    // (if ticks are painted).
    int minor = min - value;
    int major = min - value;

    // If there are no major tick marks or minor tick marks 
    // e.g. snap is set to true but no ticks are set, then
    // we can just return the value.
    if (majorSpace <= 0 && minorSpace <= 0)
      return value;

    // First check the major ticks.
    if (majorSpace > 0)
      {
        int lowerBound = (value - min) / majorSpace;
        int majLower = majorSpace * lowerBound + min;
        int majHigher = majorSpace * (lowerBound + 1) + min;

        if (majHigher <= max && majHigher - value <= value - majLower)
          major = majHigher - value;
        else
          major = majLower - value;
      }

    if (minorSpace > 0)
      {
        int lowerBound = value / minorSpace;
        int minLower = minorSpace * lowerBound;
        int minHigher = minorSpace * (lowerBound + 1);

        if (minHigher <= max && minHigher - value <= value - minLower)
          minor = minHigher - value;
        else
          minor = minLower - value;
      }

    // Give preference to minor ticks
    if (Math.abs(minor) > Math.abs(major))
      return value + major;
    else
      return value + minor;
  }
  
  InputMap getInputMap(int condition) 
  {
    if (condition == JComponent.WHEN_FOCUSED)
      return (InputMap) UIManager.get("Slider.focusInputMap");
    return null;
  }

  /**
   * Returns the action map for the {@link JSlider}.  All sliders share
   * a single action map which is created the first time this method is 
   * called, then stored in the UIDefaults table for subsequent access.
   * 
   * @return The shared action map.
   */
  ActionMap getActionMap() 
  {
    ActionMap map = (ActionMap) UIManager.get("Slider.actionMap");

    if (map == null) // first time here
      {
        map = createActionMap();
        if (map != null)
          UIManager.put("Slider.actionMap", map);
      }
    return map;
  }

  /**
   * Creates the action map shared by all {@link JSlider} instances.
   * This method is called once by {@link #getActionMap()} when it 
   * finds no action map in the UIDefaults table...after the map is 
   * created, it gets added to the defaults table so that subsequent 
   * calls to {@link #getActionMap()} will return the same shared 
   * instance.
   * 
   * @return The action map.
   */
  ActionMap createActionMap()
  {
    ActionMap map = new ActionMapUIResource();
    map.put("positiveUnitIncrement", 
            new AbstractAction("positiveUnitIncrement") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                BasicSliderUI ui = (BasicSliderUI) slider.getUI();
                if (slider.getInverted())
                  ui.scrollByUnit(BasicSliderUI.NEGATIVE_SCROLL);
                else
                  ui.scrollByUnit(BasicSliderUI.POSITIVE_SCROLL);
              }
            }
    );
    map.put("negativeUnitIncrement", 
            new AbstractAction("negativeUnitIncrement") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                BasicSliderUI ui = (BasicSliderUI) slider.getUI();
                if (slider.getInverted())
                  ui.scrollByUnit(BasicSliderUI.POSITIVE_SCROLL);
                else
                  ui.scrollByUnit(BasicSliderUI.NEGATIVE_SCROLL);
              }
            }
    );
    map.put("positiveBlockIncrement", 
            new AbstractAction("positiveBlockIncrement") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                BasicSliderUI ui = (BasicSliderUI) slider.getUI();
                if (slider.getInverted())
                  ui.scrollByBlock(BasicSliderUI.NEGATIVE_SCROLL);
                else
                  ui.scrollByBlock(BasicSliderUI.POSITIVE_SCROLL);
              }
            }
    );
    map.put("negativeBlockIncrement", 
            new AbstractAction("negativeBlockIncrement") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                BasicSliderUI ui = (BasicSliderUI) slider.getUI();
                if (slider.getInverted())
                  ui.scrollByBlock(BasicSliderUI.POSITIVE_SCROLL);
                else
                  ui.scrollByBlock(BasicSliderUI.NEGATIVE_SCROLL);
              }
            }
    );
    map.put("minScroll", 
            new AbstractAction("minScroll") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                if (slider.getInverted())
                  slider.setValue(slider.getMaximum());
                else
                  slider.setValue(slider.getMinimum());   
              }
            }
    );
    map.put("maxScroll", 
            new AbstractAction("maxScroll") {
              public void actionPerformed(ActionEvent event)
              {
                JSlider slider = (JSlider) event.getSource();
                if (slider.getInverted())
                  slider.setValue(slider.getMinimum());
                else
                  slider.setValue(slider.getMaximum());                  
              }
            }
    );
    return map;
  }

  /**
   * Small utility method to save me from typing the hell out of myself in
   * paint().
   */
  private boolean hitClip(Graphics g, Rectangle r)
  {
    return g.hitClip(r.x, r.y, r.width, r.height);
  }
}