home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / JFC.bin / MotifComboBoxUI.java < prev    next >
Encoding:
Java Source  |  1998-06-30  |  11.0 KB  |  322 lines
  1. /*
  2.  * @(#)MotifComboBoxUI.java    1.14 98/04/21
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package com.sun.java.swing.plaf.motif;
  21.  
  22. import java.awt.*;
  23. import com.sun.java.swing.*;
  24. import com.sun.java.swing.plaf.*;
  25. import com.sun.java.swing.border.*;
  26. import com.sun.java.swing.plaf.basic.*;
  27. import java.io.Serializable;
  28. import java.awt.event.*;
  29.  
  30. /**
  31.  * ComboBox motif look and feel
  32.  * <p>
  33.  * Warning: serialized objects of this class will not be compatible with
  34.  * future swing releases.  The current serialization support is appropriate
  35.  * for short term storage or RMI between Swing1.0 applications.  It will
  36.  * not be possible to load serialized Swing1.0 objects with future releases
  37.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  38.  * baseline for the serialized form of Swing objects.
  39.  *
  40.  * @version 1.14 04/21/98
  41.  * @author Arnaud Weber
  42.  */
  43. public class MotifComboBoxUI extends BasicComboBoxUI implements Serializable {
  44.     Icon arrowIcon;
  45.     static final int HORIZ_MARGIN = 3;
  46.  
  47.     public static ComponentUI createUI(JComponent c) {
  48.         return new MotifComboBoxUI();
  49.     }  
  50.  
  51.     public void installUI(JComponent c) {
  52.         super.installUI(c);
  53.         c.setBorder(new CompoundBorder(MotifBorderFactory.getFocusBorder(),
  54.                                        MotifBorderFactory.getRaisedBevelBorder()));
  55.         arrowIcon = new MotifComboBoxArrowIcon(UIManager.getColor("controlHighlight"),
  56.                                                UIManager.getColor("controlShadow"),
  57.                                                UIManager.getColor("control"));
  58.  
  59.         final Component edit = editor;
  60.         SwingUtilities.invokeLater( new Runnable(){
  61.                                     public void run(){
  62.                                     if ( edit != null ){
  63.                                     edit.setBackground( UIManager.getColor( "text" ) );}}});
  64.     }
  65.  
  66.     public void uninstallUI(JComponent c) {
  67.         super.uninstallUI(c);
  68.         c.setBorder(null);
  69.     }
  70.  
  71.     protected ComboPopup createPopup() {
  72.         return new MotifComboPopup( comboBox );
  73.     }
  74.  
  75.     protected class MotifComboPopup extends BasicComboPopup {
  76.         JComboBox cBox;
  77.         public MotifComboPopup( JComboBox comboBox ) {
  78.             super( comboBox );
  79.             cBox = comboBox;
  80.         }
  81.         protected MouseMotionListener createListMouseMotionListener() {
  82.             return new MouseMotionAdapter() {};
  83.         }
  84.  
  85.         public KeyListener createKeyListener() {
  86.             return new MotifKeyListener();
  87.         }
  88.  
  89.         protected class MotifKeyListener extends InvocationKeyListener {
  90.             public void keyReleased( KeyEvent e ) {
  91.                 if ( !cBox.isEditable() ) {
  92.                     if ( e.getKeyCode() == KeyEvent.VK_DOWN ) {
  93.                         if ( !isVisible() ) {
  94.                             show();
  95.                         }
  96.                     }
  97.                     else {
  98.                         super.keyReleased( e );
  99.                     }
  100.                 }
  101.                 else {
  102.                     if ( e.getKeyCode() == KeyEvent.VK_UP ||
  103.                          e.getKeyCode() == KeyEvent.VK_DOWN ) {
  104.                         if ( !isVisible() ) {
  105.                             show();
  106.                         }
  107.                     }
  108.                 }
  109.             }
  110.         }
  111.     }
  112.  
  113.     protected void addSubComponents() {
  114.         if ( comboBox.isEditable() ) {
  115.             addEditor();
  116.         }
  117.  
  118.         comboBox.add( currentValuePane );
  119.     }
  120.  
  121.     protected void removeSubComponents() {
  122.         removeEditor();
  123.         comboBox.removeAll();
  124.     }
  125.  
  126.     public void paint(Graphics g, JComponent c) {
  127.         boolean hasFocus = comboBox.hasFocus();
  128.         Rectangle r;
  129.  
  130.         g.setColor(comboBox.getBackground()/*UIManager.getColor("ComboBox.control")*/);
  131.         g.fillRect(0,0,c.getWidth(),c.getHeight());
  132.  
  133.         if ( !comboBox.isEditable() ) {
  134.             r = rectangleForCurrentValue();
  135.             paintCurrentValue(g,r,hasFocus);
  136.         }
  137.         r = rectangleForArrowIcon();
  138.         arrowIcon.paintIcon(c,g,r.x,r.y);
  139.         if ( !comboBox.isEditable() ) {
  140.             Border border = comboBox.getBorder();
  141.             Insets in = border.getBorderInsets(comboBox);
  142.             // Draw the separation
  143.             r.x -= (HORIZ_MARGIN + 2);
  144.             r.y = in.top;
  145.             r.width = 1;
  146.             r.height = comboBox.getBounds().height - in.bottom - in.top;
  147.             g.setColor(UIManager.getColor("controlShadow"));
  148.             g.fillRect(r.x,r.y,r.width,r.height);
  149.             r.x++;
  150.             g.setColor(UIManager.getColor("controlHighlight"));
  151.             g.fillRect(r.x,r.y,r.width,r.height);
  152.         }
  153.     }
  154.  
  155.     public void paintCurrentValue(Graphics g,Rectangle bounds,boolean hasFocus) {
  156.         ListCellRenderer renderer = comboBox.getRenderer();
  157.         Component c;
  158.         Dimension d;
  159.         c = renderer.getListCellRendererComponent(listBox, comboBox.getSelectedItem(), -1, false, false);
  160.         c.setFont(comboBox.getFont());
  161.         if ( comboBox.isEnabled() ) {
  162.             c.setForeground(comboBox.getForeground());
  163.             c.setBackground(comboBox.getBackground());
  164.         }
  165.         else {
  166.             c.setForeground(UIManager.getColor("ComboBox.disabledForeground"));
  167.             c.setBackground(UIManager.getColor("ComboBox.disabledBackground"));
  168.         }
  169.         d  = c.getPreferredSize();
  170.         currentValuePane.paintComponent(g,c,comboBox,bounds.x,bounds.y,
  171.                                         bounds.width,d.height);
  172.     }
  173.  
  174.     protected Rectangle rectangleForArrowIcon() {
  175.         Rectangle b = comboBox.getBounds();
  176.         Border border = comboBox.getBorder();
  177.         Insets in = border.getBorderInsets(comboBox);
  178.         b.x = in.left;
  179.         b.y = in.top;
  180.         b.width -= (in.left + in.right);
  181.         b.height -= (in.top + in.bottom);
  182.  
  183.         b.x = b.x + b.width - HORIZ_MARGIN - arrowIcon.getIconWidth();
  184.         b.y = b.y + (b.height - arrowIcon.getIconHeight()) / 2;
  185.         b.width = arrowIcon.getIconWidth();
  186.         b.height = arrowIcon.getIconHeight();
  187.         return b;
  188.     }
  189.  
  190.     protected Rectangle rectangleForCurrentValue() {
  191.         Border b = comboBox.getBorder();
  192.         Dimension cbSize = comboBox.getSize();
  193.         Insets in = b.getBorderInsets(comboBox);
  194.         return new Rectangle(in.left,in.top,cbSize.width - iconAreaWidth() - in.left -in.right,
  195.                              cbSize.height - in.bottom - in.top);
  196.     }
  197.  
  198.     public int iconAreaWidth() {
  199.         if ( comboBox.isEditable() )
  200.             return arrowIcon.getIconWidth() + (2 * HORIZ_MARGIN);
  201.         else
  202.             return arrowIcon.getIconWidth() + (3 * HORIZ_MARGIN) + 2;
  203.     }
  204.  
  205.     public void configureEditor() {
  206.         super.configureEditor();
  207.         editor.setBackground( UIManager.getColor( "text" ) );
  208.     }
  209.  
  210.     public void layoutContainer(Container parent) {
  211.         if ( editor != null ) {
  212.             Rectangle cvb = rectangleForCurrentValue();
  213.             cvb.x += 1;
  214.             cvb.y += 1;
  215.             cvb.width -= 1;
  216.             cvb.height -= 2;
  217.             editor.setBounds(cvb);
  218.         }
  219.     }
  220.  
  221.     static class MotifComboBoxArrowIcon implements Icon, Serializable {
  222.         private Color lightShadow;
  223.         private Color darkShadow;
  224.         private Color fill;
  225.  
  226.         public MotifComboBoxArrowIcon(Color lightShadow, Color darkShadow, Color fill) {
  227.             this.lightShadow = lightShadow;
  228.             this.darkShadow = darkShadow;
  229.             this.fill = fill;
  230.         }
  231.  
  232.  
  233.         public void paintIcon(Component c, Graphics g, int xo, int yo) {
  234.             int w = getIconWidth();
  235.             int h = getIconHeight();
  236.  
  237.             g.setColor(lightShadow);
  238.             g.drawLine(xo, yo, xo+w-1, yo);
  239.             g.drawLine(xo, yo+1, xo+w-3, yo+1);
  240.             g.setColor(darkShadow);
  241.             g.drawLine(xo+w-2, yo+1, xo+w-1, yo+1);
  242.  
  243.             for ( int x = xo+1, y = yo+2, dx = w-6; y+1 < yo+h; y += 2 ) {
  244.                 g.setColor(lightShadow);
  245.                 g.drawLine(x, y,   x+1, y);
  246.                 g.drawLine(x, y+1, x+1, y+1);
  247.                 if ( dx > 0 ) {
  248.                     g.setColor(fill);
  249.                     g.drawLine(x+2, y,   x+1+dx, y);
  250.                     g.drawLine(x+2, y+1, x+1+dx, y+1);
  251.                 }
  252.                 g.setColor(darkShadow);
  253.                 g.drawLine(x+dx+2, y,   x+dx+3, y);
  254.                 g.drawLine(x+dx+2, y+1, x+dx+3, y+1);
  255.                 x += 1;
  256.                 dx -= 2;
  257.             }
  258.  
  259.             g.setColor(darkShadow);
  260.             g.drawLine(xo+(w/2), yo+h-1, xo+(w/2), yo+h-1); 
  261.  
  262.         }
  263.  
  264.         public int getIconWidth() {
  265.             return 11;
  266.         }
  267.  
  268.         public int getIconHeight() {
  269.             return 11;
  270.         }
  271.     }
  272.  
  273.     protected void selectNextPossibleValue() {
  274.         super.selectNextPossibleValue();
  275.     }
  276.  
  277.     protected void selectPreviousPossibleValue() {
  278.         super.selectPreviousPossibleValue();
  279.     }
  280.  
  281.     protected void addKeyAccelerators(JComponent comp) {
  282.         super.addKeyAccelerators( comp );
  283.  
  284.         final JComboBox thisComboBox = comboBox;
  285.         final MotifComboBoxUI thisUI = this;
  286.  
  287.         AbstractAction downAction = new AbstractAction() {
  288.             public void actionPerformed( ActionEvent e ) {
  289.                 thisUI.selectNextPossibleValue();
  290.             }
  291.             public boolean isEnabled() {
  292.                 return thisComboBox.isEnabled() && popupIsVisible();
  293.             }
  294.         };
  295.  
  296.         thisComboBox.registerKeyboardAction( downAction,
  297.                                              KeyStroke.getKeyStroke( KeyEvent.VK_DOWN, 0 ),
  298.                                              JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
  299.  
  300.         AbstractAction upAction = new AbstractAction() {
  301.             public void actionPerformed( ActionEvent e ) {
  302.                 thisUI.selectPreviousPossibleValue();
  303.             }
  304.             public boolean isEnabled(){
  305.                 return thisComboBox.isEnabled() && popupIsVisible();
  306.             }       
  307.         };
  308.  
  309.         thisComboBox.registerKeyboardAction( upAction,
  310.                                              KeyStroke.getKeyStroke( KeyEvent.VK_UP, 0 )
  311.                                              ,JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
  312.     }
  313.  
  314.     protected void removeKeyAccelerators(JComponent comp) {
  315.         super.removeKeyAccelerators( comp );
  316.         comboBox.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN,0));
  317.         comboBox.unregisterKeyboardAction(KeyStroke.getKeyStroke(KeyEvent.VK_UP,0));
  318.     }
  319. }
  320.  
  321.  
  322.