1. /*

  2.  * @(#)MotifComboBoxUI.java	1.32 00/02/02

  3.  *

  4.  * Copyright 1997-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. package com.sun.java.swing.plaf.motif;

  11. 

  12. import java.awt.*;

  13. import javax.swing.*;

  14. import javax.swing.plaf.*;

  15. import javax.swing.border.*;

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

  17. import java.io.Serializable;

  18. import java.awt.event.*;

  19. 

  20. /**

  21.  * ComboBox motif look and feel

  22.  * <p> * <strong>Warning:</strong>

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

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

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

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

  27.  * long term persistence.

  28.  *

  29.  * @version 1.32, 02/02/00

  30.  * @author Arnaud Weber

  31.  */

  32. public class MotifComboBoxUI extends BasicComboBoxUI implements Serializable {

  33.     Icon arrowIcon;

  34.     static final int HORIZ_MARGIN = 3;

  35. 

  36.     public static ComponentUI createUI(JComponent c) {

  37.         return new MotifComboBoxUI();

  38.     }  

  39. 

  40.     public void installUI(JComponent c) {

  41.         super.installUI(c);

  42.         arrowIcon = new MotifComboBoxArrowIcon(UIManager.getColor("controlHighlight"),

  43.                                                UIManager.getColor("controlShadow"),

  44.                                                UIManager.getColor("control"));

  45. 

  46.         Runnable initCode = new Runnable() {

  47.             public void run(){

  48.                 if ( motifGetEditor() != null ) {

  49.                     motifGetEditor().setBackground( UIManager.getColor( "text" ) );

  50.                 }

  51.             }

  52.         };

  53. 

  54.         SwingUtilities.invokeLater( initCode ); 

  55.     }

  56. 

  57.     public Dimension getMinimumSize( JComponent c ) {

  58.         if ( !isMinimumSizeDirty ) {

  59.             return new Dimension( cachedMinimumSize );

  60.         }

  61.         Dimension size;

  62.         Insets insets = getInsets();

  63.         size = getDisplaySize();

  64.         size.height += insets.top + insets.bottom;

  65.         int buttonSize = iconAreaWidth();

  66.         size.width +=  insets.left + insets.right + buttonSize;

  67. 

  68.         cachedMinimumSize.setSize( size.width, size.height ); 

  69.         isMinimumSizeDirty = false;

  70. 

  71.         return size;

  72.     }

  73. 

  74.     protected ComboPopup createPopup() {

  75.         return new MotifComboPopup( comboBox );

  76.     }

  77. 

  78.     /**

  79.      * This inner class is marked "public" due to a compiler bug.

  80.      * This class should be treated as a "protected" inner class.

  81.      * Instantiate it only within subclasses of <FooUI>.

  82.      */    	     

  83.     public class MotifComboPopup extends BasicComboPopup {

  84.         JComboBox cBox;

  85.         public MotifComboPopup( JComboBox comboBox ) {

  86.             super( comboBox );

  87.             cBox = comboBox;

  88.         }

  89. 

  90.         public MouseMotionListener createListMouseMotionListener() {

  91.            return new MouseMotionAdapter() {};

  92.         }

  93. 

  94.         public KeyListener createKeyListener() {

  95.             return new InvocationKeyHandler();

  96.         }

  97. 

  98.       /**

  99.        * This inner class is marked "public" due to a compiler bug.

  100.        * This class should be treated as a "protected" inner class.

  101.        * Instantiate it only within subclasses of <FooUI>.

  102.        */    	     

  103.         public class InvocationKeyHandler extends BasicComboPopup.InvocationKeyHandler {

  104.             public void keyReleased( KeyEvent e ) {

  105.                 if ( !cBox.isEditable() ) {

  106.                     if ( e.getKeyCode() == KeyEvent.VK_DOWN ) {

  107.                         if ( !isVisible() ) {

  108.                             show();

  109.                         }

  110.                     }

  111.                     else {

  112.                         super.keyReleased( e );

  113.                     }

  114.                 }

  115.                 else {

  116.                     if ( e.getKeyCode() == KeyEvent.VK_UP ||

  117.                          e.getKeyCode() == KeyEvent.VK_DOWN ) {

  118.                         if ( !isVisible() ) {

  119.                             show();

  120.                         }

  121.                     }

  122.                 }

  123.             }

  124.         }

  125.     }

  126. 

  127.     protected void installComponents() {

  128.         if ( comboBox.isEditable() ) {

  129.             addEditor();

  130.         }

  131. 

  132.         comboBox.add( currentValuePane );

  133.     }

  134. 

  135.     protected void uninstallComponents() {

  136.         removeEditor();

  137.         comboBox.removeAll();

  138.     }

  139. 

  140.     public void paint(Graphics g, JComponent c) {

  141.         boolean hasFocus = comboBox.hasFocus();

  142.         Rectangle r;

  143. 

  144.         g.setColor(comboBox.getBackground()/*UIManager.getColor("ComboBox.control")*/);

  145.         g.fillRect(0,0,c.getWidth(),c.getHeight());

  146. 

  147.         if ( !comboBox.isEditable() ) {

  148.             r = rectangleForCurrentValue();

  149.             paintCurrentValue(g,r,hasFocus);

  150.         }

  151.         r = rectangleForArrowIcon();

  152.         arrowIcon.paintIcon(c,g,r.x,r.y);

  153.         if ( !comboBox.isEditable() ) {

  154.             Border border = comboBox.getBorder();

  155.             Insets in;

  156.             if ( border != null ) {

  157.                 in = border.getBorderInsets(comboBox);

  158.             }

  159.             else {

  160.                 in = new Insets( 0, 0, 0, 0 );

  161.             }

  162.             // Draw the separation

  163. 	    if(MotifGraphicsUtils.isLeftToRight(comboBox)) {

  164. 	        r.x -= (HORIZ_MARGIN + 2);

  165. 	    }

  166. 	    else {

  167. 	        r.x += r.width + HORIZ_MARGIN + 1;

  168. 	    }

  169.             r.y = in.top;

  170.             r.width = 1;

  171.             r.height = comboBox.getBounds().height - in.bottom - in.top;

  172.             g.setColor(UIManager.getColor("controlShadow"));

  173.             g.fillRect(r.x,r.y,r.width,r.height);

  174.             r.x++;

  175.             g.setColor(UIManager.getColor("controlHighlight"));

  176.             g.fillRect(r.x,r.y,r.width,r.height);

  177.         }

  178.     }

  179. 

  180.     public void paintCurrentValue(Graphics g,Rectangle bounds,boolean hasFocus) {

  181.         ListCellRenderer renderer = comboBox.getRenderer();

  182.         Component c;

  183.         Dimension d;

  184.         c = renderer.getListCellRendererComponent(listBox, comboBox.getSelectedItem(), -1, false, false);

  185.         c.setFont(comboBox.getFont());

  186.         if ( comboBox.isEnabled() ) {

  187.             c.setForeground(comboBox.getForeground());

  188.             c.setBackground(comboBox.getBackground());

  189.         }

  190.         else {

  191.             c.setForeground(UIManager.getColor("ComboBox.disabledForeground"));

  192.             c.setBackground(UIManager.getColor("ComboBox.disabledBackground"));

  193.         }

  194.         d  = c.getPreferredSize();

  195.         currentValuePane.paintComponent(g,c,comboBox,bounds.x,bounds.y,

  196.                                         bounds.width,d.height);

  197.     }

  198. 

  199.     protected Rectangle rectangleForArrowIcon() {

  200.         Rectangle b = comboBox.getBounds();

  201.         Border border = comboBox.getBorder();

  202.         Insets in;

  203.         if ( border != null ) {

  204.             in = border.getBorderInsets(comboBox);

  205.         }

  206.         else {

  207.             in = new Insets( 0, 0, 0, 0 );

  208.         }

  209.         b.x = in.left;

  210.         b.y = in.top;

  211.         b.width -= (in.left + in.right);

  212.         b.height -= (in.top + in.bottom);

  213. 

  214. 	if(MotifGraphicsUtils.isLeftToRight(comboBox)) {

  215. 	    b.x = b.x + b.width - HORIZ_MARGIN - arrowIcon.getIconWidth();

  216. 	}

  217. 	else {

  218. 	    b.x += HORIZ_MARGIN;

  219. 	}

  220.         b.y = b.y + (b.height - arrowIcon.getIconHeight()) / 2;

  221.         b.width = arrowIcon.getIconWidth();

  222.         b.height = arrowIcon.getIconHeight();

  223.         return b;

  224.     }

  225. 

  226.     protected Rectangle rectangleForCurrentValue() {

  227.         int width = comboBox.getWidth();

  228.         int height = comboBox.getHeight();

  229.         Insets insets = getInsets();

  230. 	if(MotifGraphicsUtils.isLeftToRight(comboBox)) {

  231. 	    return new Rectangle(insets.left, insets.top,

  232. 				 (width - (insets.left + insets.right)) - 

  233. 				                        iconAreaWidth(),

  234. 				 height - (insets.top + insets.bottom));

  235. 	}

  236. 	else {

  237. 	    return new Rectangle(insets.left + iconAreaWidth(), insets.top,

  238. 				 (width - (insets.left + insets.right)) - 

  239. 				                        iconAreaWidth(),

  240. 				 height - (insets.top + insets.bottom));

  241. 	}

  242.     }

  243. 

  244.     public int iconAreaWidth() {

  245.         if ( comboBox.isEditable() )

  246.             return arrowIcon.getIconWidth() + (2 * HORIZ_MARGIN);

  247.         else

  248.             return arrowIcon.getIconWidth() + (3 * HORIZ_MARGIN) + 2;

  249.     }

  250. 

  251.     public void configureEditor() {

  252.         super.configureEditor();

  253.         editor.setBackground( UIManager.getColor( "text" ) );

  254.     }

  255. 

  256.     protected LayoutManager createLayoutManager() {

  257.         return new ComboBoxLayoutManager();

  258.     }

  259. 

  260.     Component motifGetEditor() {

  261.         return editor;

  262.     }

  263. 

  264.     /**

  265.      * This inner class is marked "public" due to a compiler bug.

  266.      * This class should be treated as a "protected" inner class.

  267.      * Instantiate it only within subclasses of <FooUI>.

  268.      */    	     

  269.     public class ComboBoxLayoutManager extends BasicComboBoxUI.ComboBoxLayoutManager {

  270.         public void layoutContainer(Container parent) {

  271.             if ( motifGetEditor() != null ) {

  272.                 Rectangle cvb = rectangleForCurrentValue();

  273.                 cvb.x += 1;

  274.                 cvb.y += 1;

  275.                 cvb.width -= 1;

  276.                 cvb.height -= 2;

  277.                 motifGetEditor().setBounds(cvb);

  278.             }

  279.         }    

  280.     }

  281. 

  282.     static class MotifComboBoxArrowIcon implements Icon, Serializable {

  283.         private Color lightShadow;

  284.         private Color darkShadow;

  285.         private Color fill;

  286. 

  287.         public MotifComboBoxArrowIcon(Color lightShadow, Color darkShadow, Color fill) {

  288.             this.lightShadow = lightShadow;

  289.             this.darkShadow = darkShadow;

  290.             this.fill = fill;

  291.         }

  292. 

  293. 

  294.         public void paintIcon(Component c, Graphics g, int xo, int yo) {

  295.             int w = getIconWidth();

  296.             int h = getIconHeight();

  297. 

  298.             g.setColor(lightShadow);

  299.             g.drawLine(xo, yo, xo+w-1, yo);

  300.             g.drawLine(xo, yo+1, xo+w-3, yo+1);

  301.             g.setColor(darkShadow);

  302.             g.drawLine(xo+w-2, yo+1, xo+w-1, yo+1);

  303. 

  304.             for ( int x = xo+1, y = yo+2, dx = w-6; y+1 < yo+h; y += 2 ) {

  305.                 g.setColor(lightShadow);

  306.                 g.drawLine(x, y,   x+1, y);

  307.                 g.drawLine(x, y+1, x+1, y+1);

  308.                 if ( dx > 0 ) {

  309.                     g.setColor(fill);

  310.                     g.drawLine(x+2, y,   x+1+dx, y);

  311.                     g.drawLine(x+2, y+1, x+1+dx, y+1);

  312.                 }

  313.                 g.setColor(darkShadow);

  314.                 g.drawLine(x+dx+2, y,   x+dx+3, y);

  315.                 g.drawLine(x+dx+2, y+1, x+dx+3, y+1);

  316.                 x += 1;

  317.                 dx -= 2;

  318.             }

  319. 

  320.             g.setColor(darkShadow);

  321.             g.drawLine(xo+(w2), yo+h-1, xo+(w2), yo+h-1); 

  322. 

  323.         }

  324. 

  325.         public int getIconWidth() {

  326.             return 11;

  327.         }

  328. 

  329.         public int getIconHeight() {

  330.             return 11;

  331.         }

  332.     }

  333. 

  334.     protected void selectNextPossibleValue() {

  335.         super.selectNextPossibleValue();

  336.     }

  337. 

  338.     protected void selectPreviousPossibleValue() {

  339.         super.selectPreviousPossibleValue();

  340.     }

  341. 

  342.     /**

  343.      * This method is here as a workaround for a bug in the javac compiler.

  344.      */

  345.     JComboBox motifGetComboBox() {

  346.         return comboBox;

  347.     }

  348. 

  349.     /**

  350.      * This method is here as a workaround for a bug in the javac compiler.

  351.      */

  352.     MotifComboBoxUI motifGetUI() {

  353.         return this;

  354.     }

  355. }

  356.