1. /*

  2.  * @(#)WindowsScrollBarUI.java	1.19 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 com.sun.java.swing.plaf.windows;

  9. 

  10. import java.awt.*;

  11. import java.awt.image.*;

  12. import java.lang.ref.*;

  13. import java.util.*;

  14. import javax.swing.plaf.basic.*;

  15. import javax.swing.*;

  16. import javax.swing.plaf.ComponentUI;

  17. 

  18. 

  19. 

  20. /**

  21.  * Windows rendition of the component.

  22.  * <p>

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

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

  25.  * future Swing releases.  The current serialization support is appropriate

  26.  * for short term storage or RMI between applications running the same

  27.  * version of Swing.  A future release of Swing will provide support for

  28.  * long term persistence.

  29.  */

  30. public class WindowsScrollBarUI extends BasicScrollBarUI {

  31.     private Grid thumbGrid;

  32.     private Grid highlightGrid;

  33. 

  34.     /**

  35.      * Creates a UI for a JScrollBar.

  36.      *

  37.      * @param c the text field

  38.      * @return the UI

  39.      */

  40.     public static ComponentUI createUI(JComponent c) {

  41.         return new WindowsScrollBarUI();

  42.     }

  43. 

  44.     protected void installDefaults() {

  45. 	super.installDefaults();

  46. 

  47. 	if (XPStyle.getXP() != null) {

  48. 	    scrollbar.setBorder(null);

  49. 	}

  50.     }

  51. 

  52.     public void uninstallUI(JComponent c) {

  53.         super.uninstallUI(c);

  54.         thumbGrid = highlightGrid = null;

  55.     }

  56. 

  57.     protected void configureScrollBarColors() {

  58.         super.configureScrollBarColors();

  59. 	Color color = UIManager.getColor("ScrollBar.trackForeground");

  60.         if (color != null && trackColor != null) {

  61.             thumbGrid = Grid.getGrid(color, trackColor);

  62.         }

  63. 

  64. 	color = UIManager.getColor("ScrollBar.trackHighlightForeground");

  65.         if (color != null && trackHighlightColor != null) {

  66.             highlightGrid = Grid.getGrid(color, trackHighlightColor);

  67.         }

  68.     }

  69. 

  70.     protected JButton createDecreaseButton(int orientation)  {

  71.         return new WindowsArrowButton(orientation,

  72. 				    UIManager.getColor("ScrollBar.thumb"),

  73. 				    UIManager.getColor("ScrollBar.thumbShadow"),

  74. 				    UIManager.getColor("ScrollBar.thumbDarkShadow"),

  75. 				    UIManager.getColor("ScrollBar.thumbHighlight"));

  76.     }

  77. 

  78.     protected JButton createIncreaseButton(int orientation)  {

  79.         return new WindowsArrowButton(orientation,

  80. 				    UIManager.getColor("ScrollBar.thumb"),

  81. 				    UIManager.getColor("ScrollBar.thumbShadow"),

  82. 				    UIManager.getColor("ScrollBar.thumbDarkShadow"),

  83. 				    UIManager.getColor("ScrollBar.thumbHighlight"));

  84.     }

  85. 

  86. 

  87.     protected void paintTrack(Graphics g, JComponent c, Rectangle trackBounds){

  88. 	boolean v = (scrollbar.getOrientation() == JScrollBar.VERTICAL);

  89. 

  90. 	XPStyle xp = XPStyle.getXP();

  91. 	if (xp != null) {

  92. 	    JScrollBar sb = (JScrollBar)c;

  93. 	    int index = 0;

  94. 	    // Pending: Implement rollover 1 and pressed 2

  95. 	    if (!sb.isEnabled()) {

  96. 		index = 3;

  97. 	    }

  98. 	    String category = v ? "scrollbar.lowertrackvert" : "scrollbar.lowertrackhorz";

  99. 	    xp.getSkin(category).paintSkin(g, trackBounds, index);

  100. 	} else if (thumbGrid == null) {

  101.             super.paintTrack(g, c, trackBounds);

  102.         }

  103.         else {

  104.             thumbGrid.paint(g, trackBounds.x, trackBounds.y, trackBounds.width,

  105.                             trackBounds.height);

  106.             if (trackHighlight == DECREASE_HIGHLIGHT) {

  107.                 paintDecreaseHighlight(g);

  108.             } 

  109.             else if (trackHighlight == INCREASE_HIGHLIGHT) {

  110.                 paintIncreaseHighlight(g);

  111.             }

  112.         }

  113.     }

  114. 

  115.     protected void paintThumb(Graphics g, JComponent c, Rectangle thumbBounds) {

  116. 	boolean v = (scrollbar.getOrientation() == JScrollBar.VERTICAL);

  117. 

  118. 	XPStyle xp = XPStyle.getXP();

  119. 	if (xp != null) {

  120. 	    JScrollBar sb = (JScrollBar)c;

  121. 	    int index = 0;

  122. 	    if (!sb.isEnabled()) {

  123. 		index = 3;

  124. 	    } else if (isDragging) {

  125. 		index = 2;

  126. 	    } else if (isThumbRollover()) {

  127. 		index = 1;

  128. 	    }

  129. 	    // Paint thumb

  130. 	    XPStyle.Skin skin = xp.getSkin(v ? "scrollbar.thumbbtnvert" : "scrollbar.thumbbtnhorz");

  131. 	    skin.paintSkin(g, thumbBounds, index);

  132. 	    // Paint gripper

  133. 	    skin = xp.getSkin(v ? "scrollbar.grippervert" : "scrollbar.gripperhorz");

  134. 	    skin.paintSkin(g,

  135. 			   thumbBounds.x + (thumbBounds.width  - skin.getWidth()) / 2,

  136. 			   thumbBounds.y + (thumbBounds.height - skin.getHeight()) / 2,

  137. 			   skin.getWidth(), skin.getHeight(), index);

  138. 

  139. 	} else {

  140. 	    super.paintThumb(g, c, thumbBounds);

  141. 	}

  142.     }

  143. 

  144. 

  145.     protected void paintDecreaseHighlight(Graphics g) {

  146.         if (highlightGrid == null) {

  147.             super.paintDecreaseHighlight(g);

  148.         }

  149.         else {

  150.             Insets insets = scrollbar.getInsets();

  151.             Rectangle thumbR = getThumbBounds();

  152.             int x, y, w, h;

  153. 

  154.             if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {

  155.                 x = insets.left;

  156.                 y = decrButton.getY() + decrButton.getHeight();

  157.                 w = scrollbar.getWidth() - (insets.left + insets.right);

  158.                 h = thumbR.y - y;

  159.             } 

  160.             else {

  161.                 x = decrButton.getX() + decrButton.getHeight();

  162.                 y = insets.top;

  163.                 w = thumbR.x - x;

  164.                 h = scrollbar.getHeight() - (insets.top + insets.bottom);

  165.             }

  166.             highlightGrid.paint(g, x, y, w, h);

  167. 	}

  168.     }      

  169. 	

  170. 

  171.     protected void paintIncreaseHighlight(Graphics g) {

  172.         if (highlightGrid == null) {

  173.             super.paintDecreaseHighlight(g);

  174.         }

  175.         else {

  176.             Insets insets = scrollbar.getInsets();

  177.             Rectangle thumbR = getThumbBounds();

  178.             int x, y, w, h;

  179. 

  180.             if (scrollbar.getOrientation() == JScrollBar.VERTICAL) {

  181.                 x = insets.left;

  182.                 y = thumbR.y + thumbR.height;

  183.                 w = scrollbar.getWidth() - (insets.left + insets.right);

  184.                 h = incrButton.getY() - y;

  185.             }

  186.             else {

  187.                 x = thumbR.x + thumbR.width;

  188.                 y = insets.top;

  189.                 w = incrButton.getX() - x;

  190.                 h = scrollbar.getHeight() - (insets.top + insets.bottom);

  191.             }

  192.             highlightGrid.paint(g, x, y, w, h);

  193.         }

  194.     }      

  195. 

  196. 

  197.     /**

  198.      * WindowsArrowButton is used for the buttons to position the

  199.      * document up/down. It differs from BasicArrowButton in that the

  200.      * preferred size is always a square.

  201.      */

  202.     private class WindowsArrowButton extends BasicArrowButton {

  203. 

  204.         public WindowsArrowButton(int direction, Color background, Color shadow,

  205. 			 Color darkShadow, Color highlight) {

  206. 	    super(direction, background, shadow, darkShadow, highlight);

  207. 	}

  208. 

  209.         public WindowsArrowButton(int direction) {

  210.             super(direction);

  211.         }

  212. 

  213. 	public void paint(Graphics g) {

  214. 	    XPStyle xp = XPStyle.getXP();

  215. 	    if (xp != null) {

  216. 		ButtonModel model = getModel();

  217. 		XPStyle.Skin skin = xp.getSkin("scrollbar.arrowbtn");

  218. 		int index = 0;

  219. 		switch (direction) {

  220. 		    case NORTH: index =  0; break;

  221. 		    case SOUTH: index =  4; break;

  222. 		    case WEST:  index =  8; break;

  223. 		    case EAST:  index = 12; break;

  224. 		}

  225. 

  226. 		// normal, rollover, pressed, disabled

  227. 		if (model.isArmed() && model.isPressed()) {

  228. 		    index += 2;

  229. 		} else if (!model.isEnabled()) {

  230. 		    index += 3;

  231. 		} else if (model.isRollover() || model.isPressed()) {

  232. 		    index += 1;

  233. 		}

  234. 

  235. 		skin.paintSkin(g, 0, 0, getSize().width, getSize().height, index);

  236. 	    } else {

  237. 		super.paint(g);

  238. 	    }

  239. 	}

  240. 

  241.         public Dimension getPreferredSize() {

  242.             int size = 16;

  243.             if (scrollbar != null) {

  244.                 switch (scrollbar.getOrientation()) {

  245.                 case JScrollBar.VERTICAL:

  246.                     size = scrollbar.getWidth();

  247.                     break;

  248.                 case JScrollBar.HORIZONTAL:

  249.                     size = scrollbar.getHeight();

  250.                     break;

  251.                 }

  252.                 size = Math.max(size, 5);

  253.             }

  254.             return new Dimension(size, size);

  255.         }

  256.     }

  257. 

  258. 

  259.     /**

  260.      * This should be pulled out into its own class if more classes need to

  261.      * use it.

  262.      * <p>

  263.      * Grid is used to draw the track for windows scrollbars. Grids

  264.      * are cached in a HashMap, with the key being the rgb components

  265.      * of the foreground/background colors. Further the Grid is held through

  266.      * a WeakRef so that it can be freed when no longer needed. As the

  267.      * Grid is rather expensive to draw, it is drawn in a BufferedImage.

  268.      */

  269.     private static class Grid {

  270.         private static final int BUFFER_SIZE = 64;

  271.         private static HashMap map;

  272. 

  273.         private BufferedImage image;

  274. 

  275.         static {

  276.             map = new HashMap();

  277.         }

  278. 

  279.         public static Grid getGrid(Color fg, Color bg) {

  280.             String key = fg.getRGB() + " " + bg.getRGB();

  281.             WeakReference ref = (WeakReference)map.get(key);

  282.             Grid grid = (ref == null) ? null : (Grid)ref.get();

  283.             if (grid == null) {

  284.                 grid = new Grid(fg, bg);

  285.                 map.put(key, new WeakReference(grid));

  286.             }

  287.             return grid;

  288.         }

  289. 

  290.         public Grid(Color fg, Color bg) {

  291.             int cmap[] = { fg.getRGB(), bg.getRGB() };

  292.             IndexColorModel icm = new IndexColorModel(8, 2, cmap, 0, false, -1,

  293.                                                       DataBuffer.TYPE_BYTE);

  294.             image = new BufferedImage(BUFFER_SIZE, BUFFER_SIZE,

  295.                                       BufferedImage.TYPE_BYTE_INDEXED, icm);

  296.             Graphics g = image.getGraphics();

  297.             try {

  298.                 g.setClip(0, 0, BUFFER_SIZE, BUFFER_SIZE);

  299.                 paintGrid(g, fg, bg);

  300.             }

  301.             finally {

  302.                 g.dispose();

  303.             }

  304.         }

  305. 

  306.         /**

  307.          * Paints the grid into the specified Graphics at the specified

  308.          * location.

  309.          */

  310.         public void paint(Graphics g, int x, int y, int w, int h) {

  311.             Rectangle clipRect = g.getClipBounds();

  312.             int minX = Math.max(x, clipRect.x);

  313.             int minY = Math.max(y, clipRect.y);

  314.             int maxX = Math.min(clipRect.x + clipRect.width, x + w);

  315.             int maxY = Math.min(clipRect.y + clipRect.height, y + h);

  316. 

  317.             if (maxX <= minX || maxY <= minY) {

  318.                 return;

  319.             }

  320.             int xOffset = (minX - x) % 2;

  321.             for (int xCounter = minX; xCounter < maxX;

  322.                  xCounter += BUFFER_SIZE) {

  323.                 int yOffset = (minY - y) % 2;

  324.                 int width = Math.min(BUFFER_SIZE - xOffset,

  325.                                      maxX - xCounter);

  326. 

  327.                 for (int yCounter = minY; yCounter < maxY;

  328.                      yCounter += BUFFER_SIZE) {

  329.                     int height = Math.min(BUFFER_SIZE - yOffset,

  330.                                           maxY - yCounter);

  331. 

  332.                     g.drawImage(image, xCounter, yCounter,

  333.                                 xCounter + width, yCounter + height,

  334.                                 xOffset, yOffset,

  335.                                 xOffset + width, yOffset + height, null);

  336.                     if (yOffset != 0) {

  337.                         yCounter -= yOffset;

  338.                         yOffset = 0;

  339.                     }

  340.                 }

  341.                 if (xOffset != 0) {

  342.                     xCounter -= xOffset;

  343.                     xOffset = 0;

  344.                 }

  345.             }

  346.         }

  347. 

  348.         /**

  349.          * Actually renders the grid into the Graphics <code>g</code>.

  350.          */

  351.         private void paintGrid(Graphics g, Color fg, Color bg) {

  352.             Rectangle clipRect = g.getClipBounds();

  353.             g.setColor(bg);

  354.             g.fillRect(clipRect.x, clipRect.y, clipRect.width,

  355.                        clipRect.height);

  356.             g.setColor(fg);

  357.             g.translate(clipRect.x, clipRect.y);

  358.             int width = clipRect.width;

  359.             int height = clipRect.height;

  360.             int xCounter = clipRect.x % 2;

  361.             for (int end = width - height; xCounter < end; xCounter += 2) {

  362.                 g.drawLine(xCounter, 0, xCounter + height, height);

  363.             }

  364.             for (int end = width; xCounter < end; xCounter += 2) {

  365.                 g.drawLine(xCounter, 0, width, width - xCounter);

  366.             }

  367. 

  368.             int yCounter = ((clipRect.x % 2) == 0) ? 2 : 1;

  369.             for (int end = height - width; yCounter < end; yCounter += 2) {

  370.                 g.drawLine(0, yCounter, width, yCounter + width);

  371.             }

  372.             for (int end = height; yCounter < end; yCounter += 2) {

  373.                 g.drawLine(0, yCounter, height - yCounter, height);

  374.             }

  375.             g.translate(-clipRect.x, -clipRect.y);

  376.         }

  377.     }

  378. }