1. /*

  2.  * @(#)MetalSliderUI.java	1.34 03/12/19

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package javax.swing.plaf.metal;

  9. 

  10. import javax.swing.plaf.basic.BasicSliderUI;

  11. 

  12. import java.awt.Component;

  13. import java.awt.Container;

  14. import java.awt.Graphics;

  15. import java.awt.Dimension;

  16. import java.awt.Rectangle;

  17. import java.awt.Point;

  18. import java.awt.Insets;

  19. import java.awt.Color;

  20. import java.io.Serializable;

  21. import java.awt.IllegalComponentStateException;

  22. import java.awt.Polygon;

  23. import java.beans.*;

  24. 

  25. import javax.swing.border.AbstractBorder;

  26. 

  27. import javax.swing.*;

  28. import javax.swing.event.*;

  29. import javax.swing.plaf.*;

  30. 

  31. /**

  32.  * A Java L&F implementation of SliderUI.  

  33.  * <p>

  34.  * <strong>Warning:</strong>

  35.  * Serialized objects of this class will not be compatible with

  36.  * future Swing releases. The current serialization support is

  37.  * appropriate for short term storage or RMI between applications running

  38.  * the same version of Swing.  As of 1.4, support for long term storage

  39.  * of all JavaBeans<sup><font size="-2">TM</font></sup>

  40.  * has been added to the <code>java.beans</code> package.

  41.  * Please see {@link java.beans.XMLEncoder}.

  42.  *

  43.  * @version 1.34 12/19/03

  44.  * @author Tom Santos

  45.  */

  46. public class MetalSliderUI extends BasicSliderUI {

  47. 

  48.     protected final int TICK_BUFFER = 4;

  49.     protected boolean filledSlider = false;

  50.     protected static Color thumbColor;

  51.     protected static Color highlightColor;

  52.     protected static Color darkShadowColor;

  53.     protected static int trackWidth;

  54.     protected static int tickLength;

  55.     protected static Icon horizThumbIcon;

  56.     protected static Icon vertThumbIcon;

  57. 

  58. 

  59.     protected final String SLIDER_FILL = "JSlider.isFilled";

  60. 

  61.     public static ComponentUI createUI(JComponent c)    {

  62.         return new MetalSliderUI();

  63.     }

  64. 

  65.     public MetalSliderUI() {

  66.         super( null );

  67.     }

  68. 

  69.     public void installUI( JComponent c ) {

  70.         trackWidth = ((Integer)UIManager.get( "Slider.trackWidth" )).intValue();

  71.         tickLength = ((Integer)UIManager.get( "Slider.majorTickLength" )).intValue();

  72.         horizThumbIcon = UIManager.getIcon( "Slider.horizontalThumbIcon" );

  73.         vertThumbIcon = UIManager.getIcon( "Slider.verticalThumbIcon" );

  74. 

  75. 	super.installUI( c );

  76. 

  77.         thumbColor = UIManager.getColor("Slider.thumb");

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

  79.         darkShadowColor = UIManager.getColor("Slider.darkShadow");

  80. 

  81.         scrollListener.setScrollByBlock( false );

  82. 

  83.         Object sliderFillProp = c.getClientProperty( SLIDER_FILL );

  84.         if ( sliderFillProp != null ) {

  85.             filledSlider = ((Boolean)sliderFillProp).booleanValue();

  86.         }

  87.     }

  88. 

  89.     protected PropertyChangeListener createPropertyChangeListener( JSlider slider ) {

  90.         return new MetalPropertyListener();

  91.     }

  92. 

  93.     protected class MetalPropertyListener extends BasicSliderUI.PropertyChangeHandler {

  94.         public void propertyChange( PropertyChangeEvent e ) {  // listen for slider fill

  95. 	    super.propertyChange( e );

  96. 

  97. 	    String name = e.getPropertyName();

  98. 	    if ( name.equals( SLIDER_FILL ) ) {

  99. 	        if ( e.getNewValue() != null ) {

  100. 		    filledSlider = ((Boolean)e.getNewValue()).booleanValue();

  101. 		}

  102. 		else {

  103. 		    filledSlider = false;

  104. 		}

  105. 	    }

  106. 	}

  107.     }

  108. 

  109.     public void paintThumb(Graphics g)  {

  110.         Rectangle knobBounds = thumbRect;

  111. 

  112.         g.translate( knobBounds.x, knobBounds.y );

  113. 

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

  115.             horizThumbIcon.paintIcon( slider, g, 0, 0 );

  116.         }

  117.         else {

  118.             vertThumbIcon.paintIcon( slider, g, 0, 0 );

  119.         }

  120. 

  121.         g.translate( -knobBounds.x, -knobBounds.y );

  122.     }

  123. 

  124.     /**

  125.      * If <code>chooseFirst</code>is true, <code>c1</code> is returned,

  126.      * otherwise <code>c2</code>.

  127.      */

  128.     private Color chooseColor(boolean chooseFirst, Color c1, Color c2) {

  129.         if (chooseFirst) {

  130.             return c2;

  131.         }

  132.         return c1;

  133.     }

  134. 

  135.     /**

  136.      * Returns a rectangle enclosing the track that will be painted.

  137.      */

  138.     private Rectangle getPaintTrackRect() {

  139.         int trackLeft = 0, trackRight = 0, trackTop = 0, trackBottom = 0;

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

  141.             trackBottom = (trackRect.height - 1) - getThumbOverhang();

  142.             trackTop = trackBottom - (getTrackWidth() - 1);

  143.             trackRight = trackRect.width - 1;

  144.         }

  145.         else {

  146. 	    if (MetalUtils.isLeftToRight(slider)) {

  147. 	        trackLeft = (trackRect.width - getThumbOverhang()) - 

  148. 		                                         getTrackWidth();

  149. 		trackRight = (trackRect.width - getThumbOverhang()) - 1;

  150. 	    }

  151. 	    else {

  152. 	        trackLeft = getThumbOverhang();

  153. 		trackRight = getThumbOverhang() + getTrackWidth() - 1;

  154. 	    }

  155.             trackBottom = trackRect.height - 1;

  156.         }

  157.         return new Rectangle(trackRect.x + trackLeft, trackRect.y + trackTop,

  158.                              trackRight - trackLeft, trackBottom - trackTop);

  159.     }

  160. 

  161.     public void paintTrack(Graphics g)  {

  162.         if (MetalLookAndFeel.usingOcean()) {

  163.             oceanPaintTrack(g);

  164.             return;

  165.         }

  166.         Color trackColor = !slider.isEnabled() ? MetalLookAndFeel.getControlShadow() :

  167.                            slider.getForeground();

  168. 

  169. 	boolean leftToRight = MetalUtils.isLeftToRight(slider);

  170. 

  171.         g.translate( trackRect.x, trackRect.y );

  172. 

  173.         int trackLeft = 0;

  174.         int trackTop = 0;

  175.         int trackRight = 0;

  176.         int trackBottom = 0;

  177. 

  178.         // Draw the track

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

  180.             trackBottom = (trackRect.height - 1) - getThumbOverhang();

  181.             trackTop = trackBottom - (getTrackWidth() - 1);

  182.             trackRight = trackRect.width - 1;

  183. 	}

  184. 	else {

  185. 	    if (leftToRight) {

  186. 	        trackLeft = (trackRect.width - getThumbOverhang()) - 

  187. 		                                         getTrackWidth();

  188. 		trackRight = (trackRect.width - getThumbOverhang()) - 1;

  189. 	    }

  190. 	    else {

  191. 	        trackLeft = getThumbOverhang();

  192. 		trackRight = getThumbOverhang() + getTrackWidth() - 1;

  193. 	    }

  194.             trackBottom = trackRect.height - 1;

  195. 	}

  196. 

  197. 	if ( slider.isEnabled() ) {

  198. 	    g.setColor( MetalLookAndFeel.getControlDarkShadow() );

  199. 	    g.drawRect( trackLeft, trackTop,

  200. 			(trackRight - trackLeft) - 1, (trackBottom - trackTop) - 1 );

  201. 	    

  202. 	    g.setColor( MetalLookAndFeel.getControlHighlight() );

  203. 	    g.drawLine( trackLeft + 1, trackBottom, trackRight, trackBottom );

  204. 	    g.drawLine( trackRight, trackTop + 1, trackRight, trackBottom );

  205. 

  206. 	    g.setColor( MetalLookAndFeel.getControlShadow() );

  207. 	    g.drawLine( trackLeft + 1, trackTop + 1, trackRight - 2, trackTop + 1 );

  208. 	    g.drawLine( trackLeft + 1, trackTop + 1, trackLeft + 1, trackBottom - 2 );

  209. 	}

  210. 	else {

  211. 	    g.setColor( MetalLookAndFeel.getControlShadow() );

  212. 	    g.drawRect( trackLeft, trackTop,

  213. 			(trackRight - trackLeft) - 1, (trackBottom - trackTop) - 1 );

  214. 	}

  215. 

  216.         // Draw the fill

  217. 	if ( filledSlider ) {

  218. 	    int middleOfThumb = 0;

  219. 	    int fillTop = 0;

  220. 	    int fillLeft = 0;

  221. 	    int fillBottom = 0;

  222. 	    int fillRight = 0;

  223. 

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

  225. 	        middleOfThumb = thumbRect.x + (thumbRect.width / 2);

  226. 		middleOfThumb -= trackRect.x; // To compensate for the g.translate()

  227. 		fillTop = !slider.isEnabled() ? trackTop : trackTop + 1;

  228. 		fillBottom = !slider.isEnabled() ? trackBottom - 1 : trackBottom - 2;

  229. 		

  230. 		if ( !drawInverted() ) {

  231. 		    fillLeft = !slider.isEnabled() ? trackLeft : trackLeft + 1;

  232. 		    fillRight = middleOfThumb;

  233. 		}

  234. 		else {

  235. 		    fillLeft = middleOfThumb;

  236. 		    fillRight = !slider.isEnabled() ? trackRight - 1 : trackRight - 2;

  237. 		}

  238. 	    }

  239. 	    else {

  240. 	        middleOfThumb = thumbRect.y + (thumbRect.height / 2);

  241. 		middleOfThumb -= trackRect.y; // To compensate for the g.translate()

  242. 		fillLeft = !slider.isEnabled() ? trackLeft : trackLeft + 1;

  243. 		fillRight = !slider.isEnabled() ? trackRight - 1 : trackRight - 2;

  244. 		

  245. 		if ( !drawInverted() ) {

  246. 		    fillTop = middleOfThumb;

  247. 		    fillBottom = !slider.isEnabled() ? trackBottom - 1 : trackBottom - 2;

  248. 		}

  249. 		else {

  250. 		    fillTop = !slider.isEnabled() ? trackTop : trackTop + 1;

  251. 		    fillBottom = middleOfThumb;

  252. 		}

  253. 	    }

  254. 	    

  255. 	    if ( slider.isEnabled() ) {

  256. 	        g.setColor( slider.getBackground() );

  257. 		g.drawLine( fillLeft, fillTop, fillRight, fillTop );

  258. 		g.drawLine( fillLeft, fillTop, fillLeft, fillBottom );

  259. 

  260. 		g.setColor( MetalLookAndFeel.getControlShadow() );

  261. 		g.fillRect( fillLeft + 1, fillTop + 1,

  262. 			    fillRight - fillLeft, fillBottom - fillTop );

  263. 	    }

  264. 	    else {

  265. 	        g.setColor( MetalLookAndFeel.getControlShadow() );

  266. 		g.fillRect( fillLeft, fillTop,

  267. 			    fillRight - fillLeft, trackBottom - trackTop );

  268. 	    }

  269. 	}

  270. 

  271.         g.translate( -trackRect.x, -trackRect.y );

  272.     }

  273. 

  274.     private void oceanPaintTrack(Graphics g)  {

  275. 	boolean leftToRight = MetalUtils.isLeftToRight(slider);

  276.         boolean drawInverted = drawInverted();

  277.         Color sliderAltTrackColor = (Color)UIManager.get(

  278.                                     "Slider.altTrackColor");

  279. 

  280.         // Translate to the origin of the painting rectangle

  281.         Rectangle paintRect = getPaintTrackRect();

  282.         g.translate(paintRect.x, paintRect.y);

  283. 

  284.         // Width and height of the painting rectangle.

  285.         int w = paintRect.width;

  286.         int h = paintRect.height;

  287. 

  288.         if (!slider.isEnabled()) {

  289.             g.setColor(MetalLookAndFeel.getControlShadow());

  290.             g.drawRect(0, 0, w - 1, h - 1);

  291.         }

  292. 	else if (slider.getOrientation() == JSlider.HORIZONTAL) {

  293.             int middleOfThumb = thumbRect.x + (thumbRect.width / 2) -

  294.                                 paintRect.x;

  295.             int fillMinX;

  296.             int fillMaxX;

  297. 

  298.             if (middleOfThumb > 0) {

  299.                 g.setColor(chooseColor(drawInverted,

  300.                            MetalLookAndFeel.getPrimaryControlDarkShadow(),

  301.                            MetalLookAndFeel.getControlDarkShadow()));

  302.                g.drawRect(0, 0, middleOfThumb - 1, h - 1);

  303.             }

  304.             if (middleOfThumb < w) {

  305.                 g.setColor(chooseColor(drawInverted,

  306.                            MetalLookAndFeel.getControlDarkShadow(),

  307.                            MetalLookAndFeel.getPrimaryControlDarkShadow()));

  308.                 g.drawRect(middleOfThumb, 0, w - middleOfThumb - 1, h - 1);

  309.             }

  310.             g.setColor(MetalLookAndFeel.getPrimaryControlShadow());

  311.             if (drawInverted) {

  312.                 fillMinX = middleOfThumb;

  313.                 fillMaxX = w - 2;

  314.                 g.drawLine(1, 1, middleOfThumb, 1);

  315.             }

  316.             else {

  317.                 fillMinX = 1;

  318.                 fillMaxX = middleOfThumb;

  319.                 g.drawLine(middleOfThumb, 1, w - 1, 1);

  320.             }

  321.             if (h == 6) {

  322.                 g.setColor(MetalLookAndFeel.getWhite());

  323.                 g.drawLine(fillMinX, 1, fillMaxX, 1);

  324.                 g.setColor(sliderAltTrackColor);

  325.                 g.drawLine(fillMinX, 2, fillMaxX, 2);

  326.                 g.setColor(MetalLookAndFeel.getControlShadow());

  327.                 g.drawLine(fillMinX, 3, fillMaxX, 3);

  328.                 g.setColor(MetalLookAndFeel.getPrimaryControlShadow());

  329.                 g.drawLine(fillMinX, 4, fillMaxX, 4);

  330.             }

  331.         }

  332.         else {

  333.             int middleOfThumb = thumbRect.y + (thumbRect.height / 2) -

  334.                                 paintRect.y;

  335.             int fillMinY;

  336.             int fillMaxY;

  337. 

  338.             if (middleOfThumb > 0) {

  339.                 g.setColor(chooseColor(drawInverted,

  340.                            MetalLookAndFeel.getControlDarkShadow(),

  341.                            MetalLookAndFeel.getPrimaryControlDarkShadow()));

  342.                 g.drawRect(0, 0, w - 1, middleOfThumb - 1);

  343.             }

  344.             if (middleOfThumb < h) {

  345.                 g.setColor(chooseColor(drawInverted,

  346.                            MetalLookAndFeel.getPrimaryControlDarkShadow(),

  347.                            MetalLookAndFeel.getControlDarkShadow()));

  348.                 g.drawRect(0, middleOfThumb, w - 1, h - middleOfThumb - 1);

  349.             }

  350.             g.setColor(MetalLookAndFeel.getPrimaryControlShadow());

  351.             if (drawInverted()) {

  352.                 fillMinY = 1;

  353.                 fillMaxY = middleOfThumb;

  354.                 if (leftToRight) {

  355.                     g.drawLine(1, middleOfThumb, 1, h - 1);

  356.                 }

  357.                 else {

  358.                     g.drawLine(w - 2, middleOfThumb, w - 2, h - 1);

  359.                 }

  360.             }

  361.             else {

  362.                 fillMinY = middleOfThumb;

  363.                 fillMaxY = h - 2;

  364.                 if (leftToRight) {

  365.                     g.drawLine(1, 1, 1, middleOfThumb);

  366.                 }

  367.                 else {

  368.                     g.drawLine(w - 2, 1, w - 2, middleOfThumb);

  369.                 }

  370.             }

  371.             if (w == 6) {

  372.                 g.setColor(chooseColor(!leftToRight,

  373.                            MetalLookAndFeel.getWhite(),

  374.                            MetalLookAndFeel.getPrimaryControlShadow()));

  375.                 g.drawLine(1, fillMinY, 1, fillMaxY);

  376.                 g.setColor(chooseColor(!leftToRight, sliderAltTrackColor,

  377.                            MetalLookAndFeel.getControlShadow()));

  378.                 g.drawLine(2, fillMinY, 2, fillMaxY);

  379.                 g.setColor(chooseColor(!leftToRight,

  380.                            MetalLookAndFeel.getControlShadow(),

  381.                            sliderAltTrackColor));

  382.                 g.drawLine(3, fillMinY, 3, fillMaxY);

  383.                 g.setColor(chooseColor(!leftToRight,

  384.                            MetalLookAndFeel.getPrimaryControlShadow(),

  385.                            MetalLookAndFeel.getWhite()));

  386.                 g.drawLine(4, fillMinY, 4, fillMaxY);

  387.             }

  388.         }

  389. 

  390.         g.translate(-paintRect.x, -paintRect.y);

  391.     }

  392. 

  393.     public void paintFocus(Graphics g)  {        

  394.     }

  395. 

  396.     protected Dimension getThumbSize() {

  397.         Dimension size = new Dimension();

  398. 

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

  400. 	    size.width = vertThumbIcon.getIconWidth();

  401. 	    size.height = vertThumbIcon.getIconHeight();

  402. 	}

  403. 	else {

  404. 	    size.width = horizThumbIcon.getIconWidth();

  405. 	    size.height = horizThumbIcon.getIconHeight();

  406. 	}

  407. 

  408. 	return size;

  409.     }

  410. 

  411.     /**

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

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

  414.      * determine the tick area rectangle.

  415.      */

  416.     public int getTickLength() {

  417.         return slider.getOrientation() == JSlider.HORIZONTAL ? tickLength + TICK_BUFFER + 1 :

  418.         tickLength + TICK_BUFFER + 3;

  419.     }

  420. 

  421.     /**

  422.      * Returns the shorter dimension of the track.

  423.      */

  424.     protected int getTrackWidth() {

  425.         // This strange calculation is here to keep the

  426.         // track in proportion to the thumb.

  427.         final double kIdealTrackWidth = 7.0;

  428. 	final double kIdealThumbHeight = 16.0;

  429.         final double kWidthScalar = kIdealTrackWidth / kIdealThumbHeight;

  430. 

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

  432. 	    return (int)(kWidthScalar * thumbRect.height);

  433. 	}

  434. 	else {

  435. 	    return (int)(kWidthScalar * thumbRect.width);

  436. 	}

  437.     }

  438. 

  439.     /**

  440.      * Returns the longer dimension of the slide bar.  (The slide bar is only the

  441.      * part that runs directly under the thumb)

  442.      */

  443.     protected int getTrackLength() {   

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

  445.             return trackRect.width; 

  446.         }

  447.         return trackRect.height;

  448.     }

  449. 

  450.     /**

  451.      * Returns the amount that the thumb goes past the slide bar.

  452.      */

  453.     protected int getThumbOverhang() {

  454.         return (int)(getThumbSize().getHeight()-getTrackWidth())/2;

  455.     }

  456. 

  457.     protected void scrollDueToClickInTrack( int dir ) {

  458.         scrollByUnit( dir );

  459.     }

  460. 

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

  462.         g.setColor( slider.isEnabled() ? slider.getForeground() : MetalLookAndFeel.getControlShadow() );

  463.         g.drawLine( x, TICK_BUFFER, x, TICK_BUFFER + (tickLength / 2) );

  464.     }

  465. 

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

  467.         g.setColor( slider.isEnabled() ? slider.getForeground() : MetalLookAndFeel.getControlShadow() );

  468.         g.drawLine( x, TICK_BUFFER , x, TICK_BUFFER + (tickLength - 1) );

  469.     }

  470. 

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

  472.         g.setColor( slider.isEnabled() ? slider.getForeground() : MetalLookAndFeel.getControlShadow() );

  473. 

  474. 	if (MetalUtils.isLeftToRight(slider)) {

  475. 	    g.drawLine( TICK_BUFFER, y, TICK_BUFFER + (tickLength / 2), y );

  476. 	}

  477. 	else {

  478. 	    g.drawLine( 0, y, tickLength2, y );

  479. 	}

  480.     }

  481. 

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

  483.         g.setColor( slider.isEnabled() ? slider.getForeground() : MetalLookAndFeel.getControlShadow() );

  484. 

  485. 	if (MetalUtils.isLeftToRight(slider)) {

  486. 	    g.drawLine( TICK_BUFFER, y, TICK_BUFFER + tickLength, y );

  487. 	}

  488. 	else {

  489. 	    g.drawLine( 0, y, tickLength, y );

  490. 	}

  491.     }

  492. }