1. /*

  2.  * @(#)MetalComboBoxUI.java	1.29 00/02/02

  3.  *

  4.  * Copyright 1998-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. 

  11. package javax.swing.plaf.metal;

  12. 

  13. import java.awt.*;

  14. import java.awt.event.*;

  15. import javax.swing.*;

  16. import javax.swing.plaf.*;

  17. import javax.swing.border.*;

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

  19. import java.io.Serializable;

  20. import java.beans.*;

  21. 

  22. 

  23. /**

  24.  * Metal UI for JComboBox

  25.  * <p>

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

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

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

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

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

  31.  * long term persistence.

  32.  *

  33.  * @see MetalComboBoxListCellRenderer

  34.  * @see MetalPopupMenuBorder

  35.  * @version 1.29 02/02/00

  36.  * @author Tom Santos

  37.  */

  38. public class MetalComboBoxUI extends BasicComboBoxUI {

  39. 

  40.     FocusListener focusDelegator;

  41. 

  42.     public static ComponentUI createUI(JComponent c) {

  43.         return new MetalComboBoxUI();

  44.     }

  45. 

  46.     public void installUI(JComponent c) {

  47.         super.installUI(c);

  48.         comboBox.setRequestFocusEnabled( true );

  49.     }

  50. 

  51.     public void uninstallUI( JComponent c ) {

  52.         super.uninstallUI( c ); 

  53.     }

  54. 

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

  56.     }

  57. 

  58.     protected ComboBoxEditor createEditor() {

  59.         return new MetalComboBoxEditor.UIResource();

  60.     }

  61. 

  62.     protected ComboPopup createPopup() {

  63.         return new MetalComboPopup( comboBox );

  64.     }

  65. 

  66.     protected JButton createArrowButton() {

  67.         JButton button = new MetalComboBoxButton( comboBox,

  68.                                                   new MetalComboBoxIcon(),

  69.                                                   comboBox.isEditable() ? true : false,

  70.                                                   currentValuePane,

  71.                                                   listBox );

  72.         button.setMargin( new Insets( 0, 1, 1, 3 ) );

  73.         return button;

  74.     }

  75. 

  76.     FocusListener createFocusDelegator() {

  77.         return new FocusDelegator();

  78.     }

  79. 

  80.     class FocusDelegator extends FocusAdapter {

  81.         public void focusGained( FocusEvent e ) {

  82.             if ( metalGetComboBox().isEditable() ) {

  83.                 metalGetEditor().requestFocus();

  84.             }

  85.             else {

  86.                 metalGetArrowButton().requestFocus();

  87.             }

  88.         }

  89.     }

  90. 

  91.     public PropertyChangeListener createPropertyChangeListener() {

  92.         return new MetalPropertyChangeListener();

  93.     }

  94. 

  95.     /**

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

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

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

  99.      */          

  100.     public class MetalPropertyChangeListener extends BasicComboBoxUI.PropertyChangeHandler {

  101.         public void propertyChange(PropertyChangeEvent e) {

  102.             super.propertyChange( e );

  103.             metalGetComboBox().setRequestFocusEnabled( true );

  104. 

  105.             String propertyName = e.getPropertyName();

  106. 

  107.             if ( propertyName.equals( "editable" ) ) {

  108.                 editablePropertyChanged( e );

  109.             }

  110.             else if ( propertyName.equals( "enabled" ) ) {

  111.                 enabledPropertyChanged( e );

  112.             }

  113.         }

  114.     }

  115. 

  116.     protected void editablePropertyChanged( PropertyChangeEvent e ) {

  117.         if ( arrowButton instanceof MetalComboBoxButton ) {

  118.             MetalComboBoxButton button = (MetalComboBoxButton)arrowButton;

  119.             button.setIconOnly( comboBox.isEditable() );

  120.             button.setRequestFocusEnabled( (!comboBox.isEditable()) && comboBox.isEnabled() );

  121.             comboBox.repaint();

  122.         }

  123.     }

  124. 

  125.     void enabledPropertyChanged( PropertyChangeEvent e ) {

  126.         if ( arrowButton instanceof MetalComboBoxButton ) {

  127.             arrowButton.setRequestFocusEnabled( (!comboBox.isEditable()) && comboBox.isEnabled() );

  128.             comboBox.repaint();

  129.         }

  130.     }

  131. 

  132.     protected LayoutManager createLayoutManager() {

  133.         return new MetalComboBoxLayoutManager();

  134.     }

  135. 

  136.     /**

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

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

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

  140.      */          

  141.     public class MetalComboBoxLayoutManager extends BasicComboBoxUI.ComboBoxLayoutManager {

  142.         public void layoutContainer( Container parent ) {

  143.             layoutComboBox( parent, this );

  144.         }

  145.         public void superLayout( Container parent ) {

  146.             super.layoutContainer( parent );

  147.         }

  148.     }

  149. 

  150.     // This is here because of a bug in the compiler.  When a protected-inner-class-savvy compiler comes out we

  151.     // should move this into MetalComboBoxLayoutManager.

  152.     public void layoutComboBox( Container parent, MetalComboBoxLayoutManager manager ) {

  153.         if ( comboBox.isEditable() ) {

  154.             manager.superLayout( parent );

  155.         }

  156.         else {

  157.             if ( arrowButton != null ) {

  158.                 Insets insets = comboBox.getInsets();

  159.                 int width = comboBox.getWidth();

  160.                 int height = comboBox.getHeight();

  161.                 arrowButton.setBounds( insets.left, insets.top,

  162.                                        width - (insets.left + insets.right),

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

  164.             }

  165.         }

  166.     }

  167. 

  168.     public boolean isFocusTraversable( JComboBox c ) {

  169.         return false;

  170.     }

  171. 

  172.     protected void installListeners() {

  173.         if ( (itemListener = createItemListener()) != null ) {

  174.             comboBox.addItemListener( itemListener );

  175.         }

  176.         if ( (propertyChangeListener = createPropertyChangeListener()) != null ) {

  177.             comboBox.addPropertyChangeListener( propertyChangeListener );

  178.         }

  179. 

  180.         keyListener = createKeyListener();

  181.         focusListener = createFocusListener();

  182.         popupKeyListener = popup.getKeyListener();

  183.         popupMouseListener = popup.getMouseListener();

  184.         popupMouseMotionListener = popup.getMouseMotionListener();

  185. 

  186.         if ( comboBox.getModel() != null ) {

  187.             if ( (listDataListener = createListDataListener()) != null ) {

  188.                 comboBox.getModel().addListDataListener( listDataListener );

  189.             }

  190.         }

  191. 

  192.         if ( (focusDelegator = createFocusDelegator()) != null ) {

  193.             comboBox.addFocusListener( focusDelegator );

  194.         }

  195.     }

  196. 

  197.     protected void uninstallListeners() {

  198.         if ( itemListener != null ) {

  199.             comboBox.removeItemListener( itemListener );

  200.         }

  201.         if ( propertyChangeListener != null ) {

  202.             comboBox.removePropertyChangeListener( propertyChangeListener );

  203.         }

  204.         if ( comboBox.getModel() != null ) {

  205.             if ( listDataListener != null ) {

  206.                 comboBox.getModel().removeListDataListener( listDataListener );

  207.             }

  208.         }

  209.         if ( focusDelegator != null ) {

  210.             comboBox.removeFocusListener( focusDelegator );

  211.         }

  212.     }

  213. 

  214.     protected void removeListeners() {

  215.         if ( itemListener != null ) {

  216.             comboBox.removeItemListener( itemListener );

  217.         }

  218.         if ( propertyChangeListener != null ) {

  219.             comboBox.removePropertyChangeListener( propertyChangeListener );

  220.         }

  221.     }

  222. 

  223.     public void configureEditor() {

  224.         super.configureEditor();

  225.         if ( popupKeyListener != null ) {

  226.             editor.removeKeyListener( popupKeyListener );

  227.         }

  228.         if ( focusListener != null ) {

  229.             editor.addFocusListener( focusListener );

  230.         }

  231.     }

  232. 

  233.     public void unconfigureEditor() {

  234.         super.unconfigureEditor();

  235.         if ( focusListener != null ) {

  236.             editor.removeFocusListener( focusListener );

  237.         }

  238.     }

  239. 

  240.     public void configureArrowButton() {

  241.         if ( arrowButton != null ) {

  242.             arrowButton.setRequestFocusEnabled( (!comboBox.isEditable()) && comboBox.isEnabled() );

  243.             if ( keyListener != null ) {

  244.                 arrowButton.addKeyListener( keyListener );

  245.             }

  246.             if ( popupKeyListener != null ) {

  247.                 arrowButton.addKeyListener( popupKeyListener );

  248.             }

  249.             if ( focusListener != null ) {

  250.                 arrowButton.addFocusListener( focusListener );

  251.             }

  252.             if ( popupMouseListener != null ) {

  253.                 arrowButton.addMouseListener( popupMouseListener );

  254.             }

  255.             if ( popupMouseMotionListener != null ) {

  256.                 arrowButton.addMouseMotionListener( popupMouseMotionListener );

  257.             }

  258.         }

  259.     }

  260. 

  261.     public void unconfigureArrowButton() {

  262.         if ( arrowButton != null ) {

  263.             super.unconfigureArrowButton();

  264. 

  265.             if ( keyListener != null ) {

  266.                 arrowButton.removeKeyListener( keyListener );

  267.             }

  268.             if ( popupKeyListener != null ) {

  269.                 arrowButton.removeKeyListener( popupKeyListener );

  270.             }

  271.             if ( focusListener != null ) {

  272.                 arrowButton.removeFocusListener( focusListener );

  273.             }

  274.         }

  275.     }

  276. 

  277.     public Dimension getMinimumSize( JComponent c ) {

  278.         if ( !isMinimumSizeDirty ) {

  279.             return new Dimension( cachedMinimumSize );

  280.         }

  281. 

  282.         Dimension size = null;

  283. 

  284.         if ( !comboBox.isEditable() &&

  285.              arrowButton != null &&

  286.              arrowButton instanceof MetalComboBoxButton ) {

  287. 

  288.             MetalComboBoxButton button = (MetalComboBoxButton)arrowButton;

  289.             Insets buttonInsets = button.getInsets();

  290.             Insets insets = comboBox.getInsets();

  291. 

  292.             size = getDisplaySize();

  293.             size.width += insets.left + insets.right;

  294.             size.width += buttonInsets.left + buttonInsets.right;

  295.             size.width += buttonInsets.right + button.getComboIcon().getIconWidth();

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

  297.             size.height += buttonInsets.top + buttonInsets.bottom;

  298.         }

  299.         else if ( comboBox.isEditable() &&

  300.                   arrowButton != null &&

  301.                   editor != null ) {

  302.             size = super.getMinimumSize( c );

  303.             Insets margin = arrowButton.getMargin();

  304.             Insets insets = comboBox.getInsets();

  305.             if ( editor instanceof JComponent ) {

  306.                 Insets editorInsets = ((JComponent)editor).getInsets();

  307.                 size.height += editorInsets.top + editorInsets.bottom;

  308.             }

  309.             size.height += margin.top + margin.bottom;

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

  311.         }

  312.         else {

  313.             size = super.getMinimumSize( c );

  314.         }

  315. 

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

  317.         isMinimumSizeDirty = false;

  318. 

  319.         return new Dimension( cachedMinimumSize );

  320.     }

  321. 

  322.     protected void selectNextPossibleValue() { super.selectNextPossibleValue();}

  323.     protected void selectPreviousPossibleValue() { super.selectPreviousPossibleValue();}

  324. 

  325.     /**

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

  327.      */

  328.     JComboBox metalGetComboBox() {

  329.         return comboBox;

  330.     }

  331. 

  332.     /**

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

  334.      */

  335.     JButton getArrowButton() {

  336.         return arrowButton;

  337.     }

  338. 

  339.     boolean isPopupVisible() {

  340.         return super.isPopupVisible( comboBox );

  341.     }

  342. 

  343.     void togglePopup() {

  344.        toggleOpenClose();

  345.     }

  346. 

  347.     Component metalGetEditor() {

  348.         return editor;

  349.     }

  350. 

  351.     JButton metalGetArrowButton() {

  352.         return arrowButton;

  353.     }

  354. 

  355.     /**

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

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

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

  359.      */          

  360.     public class MetalComboPopup extends BasicComboPopup {

  361.         public MetalComboPopup( JComboBox cBox ) {

  362.             super( cBox );

  363.         }

  364. 

  365.         public void delegateFocus( MouseEvent e ) {

  366.             if ( metalGetComboBox().isEditable() ) {

  367.                 metalGetEditor().requestFocus();

  368.             }

  369.         }

  370.     }

  371. }

  372. 

  373.