1. /*

  2.  * @(#)BasicButtonUI.java	1.98 01/11/29

  3.  *

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

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

  6.  */

  7.  

  8. package javax.swing.plaf.basic;

  9. 

  10. import java.awt.*;

  11. import java.awt.event.*;

  12. import java.io.Serializable;

  13. import javax.swing.*;

  14. import javax.swing.border.*;

  15. import java.awt.*;

  16. import java.awt.event.*;

  17. import javax.swing.plaf.ButtonUI;

  18. import javax.swing.plaf.UIResource;

  19. import javax.swing.plaf.ComponentUI;

  20. import javax.swing.text.View;

  21. 

  22. /**

  23.  * BasicButton implementation

  24.  *

  25.  * @version 1.98 11/29/01

  26.  * @author Jeff Dinkins

  27.  */

  28. public class BasicButtonUI extends ButtonUI{

  29.     // Shared UI object

  30.     private final static BasicButtonUI buttonUI = new BasicButtonUI();

  31. 

  32.     // Visual constants

  33.     protected int defaultTextIconGap;

  34.     

  35.     // Offset controlled by set method 

  36.     private int shiftOffset = 0;

  37.     protected int defaultTextShiftOffset;

  38. 

  39.     // Has the shared instance defaults been initialized?

  40.     private boolean defaults_initialized = false;

  41. 

  42.     private final static String propertyPrefix = "Button" + ".";

  43. 

  44.     // ********************************

  45.     //          Create PLAF

  46.     // ********************************

  47.     public static ComponentUI createUI(JComponent c) {

  48.         return buttonUI;

  49.     }

  50. 

  51.     protected String getPropertyPrefix() {

  52.         return propertyPrefix;

  53.     }

  54. 

  55. 

  56.     // ********************************

  57.     //          Install PLAF

  58.     // ********************************

  59.     public void installUI(JComponent c) {

  60.         installDefaults((AbstractButton) c);

  61.         installListeners((AbstractButton) c);

  62.         installKeyboardActions((AbstractButton) c);

  63. 	BasicHTML.updateRenderer(c, ((AbstractButton) c).getText());

  64.     }

  65. 

  66.     private Color defaultForeground = null;

  67.     private Color defaultBackground = null;

  68.     private Font defaultFont = null;

  69.     private Border defaultBorder = null;

  70. 

  71.     protected void installDefaults(AbstractButton b) {

  72.         // load shared instance defaults

  73.         String pp = getPropertyPrefix();

  74.         if(!defaults_initialized) {

  75.             defaultTextIconGap = ((Integer)UIManager.get(pp + "textIconGap")).intValue();

  76.             defaultTextShiftOffset = ((Integer)UIManager.get(pp + "textShiftOffset")).intValue();

  77.         

  78. 	    // next four lines part of optimized component defaults installation

  79. 	   /* defaultForeground = UIManager.getColor(pp + "foreground");

  80. 	    defaultBackground = UIManager.getColor(pp + "background");

  81. 	    defaultFont = UIManager.getFont(pp + "font");

  82. 	    defaultBorder = UIManager.getBorder(pp + "border");*/

  83. 

  84.             defaults_initialized = true;

  85.         }

  86. 

  87.         // set the following defaults on the button

  88.         if (b.isContentAreaFilled()) {

  89.             b.setOpaque(true); 

  90.         } else {

  91.             b.setOpaque(false);

  92.         }

  93. 

  94.         if(b.getMargin() == null || (b.getMargin() instanceof UIResource)) {

  95.             b.setMargin(UIManager.getInsets(pp + "margin"));

  96.         }

  97. 

  98. 	// *** begin optimized defaults install ***

  99. 

  100. /*	Color currentForeground = b.getForeground();

  101. 	Color currentBackground = b.getBackground();

  102. 	Font currentFont = b.getFont();

  103. 	Border currentBorder = b.getBorder();

  104. 

  105. 	if (currentForeground == null || currentForeground instanceof UIResource) {

  106. 	      b.setForeground(defaultForeground);

  107. 	}

  108. 

  109. 	if (currentBackground == null || currentBackground instanceof UIResource) {

  110.               b.setBackground(defaultBackground);

  111. 	}

  112. 

  113. 	if (currentFont == null || currentFont instanceof UIResource) {

  114. 	      b.setFont(defaultFont);

  115. 	}

  116. 

  117. 	if (currentBorder == null || currentBorder instanceof UIResource) {

  118. 	      b.setBorder(defaultBorder);

  119. 	} */

  120. 

  121. 	// *** end optimized defaults install ***

  122. 

  123. 	// old code below works for component defaults installation, but it is slow

  124. 	LookAndFeel.installColorsAndFont(b, pp + "background", pp + "foreground", pp + "font");

  125.         LookAndFeel.installBorder(b, pp + "border");

  126. 

  127.     }

  128. 

  129.     protected void installListeners(AbstractButton b) {

  130.         BasicButtonListener listener = createButtonListener(b);

  131.         if(listener != null) {

  132.             // put the listener in the button's client properties so that

  133.             // we can get at it later

  134.             b.putClientProperty(this, listener);

  135. 

  136.             b.addMouseListener(listener);

  137.             b.addMouseMotionListener(listener);

  138.             b.addFocusListener(listener);

  139.             b.addPropertyChangeListener(listener);

  140.             b.addChangeListener(listener);

  141.         }

  142.     }

  143.     

  144.     protected void installKeyboardActions(AbstractButton b){

  145.         BasicButtonListener listener = (BasicButtonListener) b.getClientProperty(this);

  146.         if(listener != null) {

  147.             listener.installKeyboardActions(b);

  148.         }

  149.     }

  150. 

  151.         

  152.     // ********************************

  153.     //         Uninstall PLAF

  154.     // ********************************

  155.     public void uninstallUI(JComponent c) {

  156.         uninstallKeyboardActions((AbstractButton) c);

  157.         uninstallListeners((AbstractButton) c);

  158.         uninstallDefaults((AbstractButton) c);

  159. 	BasicHTML.updateRenderer(c, "");

  160.     }

  161. 

  162.     protected void uninstallKeyboardActions(AbstractButton b) {

  163.         BasicButtonListener listener = (BasicButtonListener) b.getClientProperty(this);

  164.         if(listener != null) {

  165.             listener.uninstallKeyboardActions(b);

  166.         }

  167.     }

  168. 

  169.     protected void uninstallListeners(AbstractButton b) {

  170.         BasicButtonListener listener = (BasicButtonListener) b.getClientProperty(this);

  171.         b.putClientProperty(this, null);

  172.         if(listener != null) {

  173.             b.removeMouseListener(listener);

  174.             b.removeMouseListener(listener);

  175.             b.removeMouseMotionListener(listener);

  176.             b.removeFocusListener(listener);

  177.             b.removeChangeListener(listener);

  178.             b.removePropertyChangeListener(listener);

  179.         }

  180.     }

  181. 

  182.     protected void uninstallDefaults(AbstractButton b) {

  183.         LookAndFeel.uninstallBorder(b);

  184.         defaults_initialized = false;

  185.     }

  186.   

  187.     // ********************************

  188.     //        Create Listeners 

  189.     // ********************************

  190.     protected BasicButtonListener createButtonListener(AbstractButton b) {

  191.         return new BasicButtonListener(b);

  192.     }

  193. 

  194.     public int getDefaultTextIconGap(AbstractButton b) {

  195.         return defaultTextIconGap;

  196.     }

  197. 

  198.     /* These rectangles/insets are allocated once for all 

  199.      * ButtonUI.paint() calls.  Re-using rectangles rather than 

  200.      * allocating them in each paint call substantially reduced the time

  201.      * it took paint to run.  Obviously, this method can't be re-entered.

  202.      */

  203.     private static Rectangle viewRect = new Rectangle();

  204.     private static Rectangle textRect = new Rectangle();

  205.     private static Rectangle iconRect = new Rectangle();

  206. 

  207.     // ********************************

  208.     //          Paint Methods

  209.     // ********************************

  210. 

  211.     public void paint(Graphics g, JComponent c) 

  212.     {

  213.         AbstractButton b = (AbstractButton) c;

  214.         ButtonModel model = b.getModel();

  215. 

  216.         FontMetrics fm = g.getFontMetrics();

  217. 

  218.         Insets i = c.getInsets();

  219. 

  220.         viewRect.x = i.left;

  221.         viewRect.y = i.top;

  222.         viewRect.width = b.getWidth() - (i.right + viewRect.x);

  223.         viewRect.height = b.getHeight() - (i.bottom + viewRect.y);

  224. 

  225.         textRect.x = textRect.y = textRect.width = textRect.height = 0;

  226.         iconRect.x = iconRect.y = iconRect.width = iconRect.height = 0;

  227. 

  228.         Font f = c.getFont();

  229.         g.setFont(f);

  230. 

  231.         // layout the text and icon

  232.         String text = SwingUtilities.layoutCompoundLabel(

  233.             c, fm, b.getText(), b.getIcon(), 

  234.             b.getVerticalAlignment(), b.getHorizontalAlignment(),

  235.             b.getVerticalTextPosition(), b.getHorizontalTextPosition(),

  236.             viewRect, iconRect, textRect, 

  237.             b.getText() == null ? 0 : defaultTextIconGap

  238.         );

  239. 

  240.         clearTextShiftOffset();

  241. 

  242.         // perform UI specific press action, e.g. Windows L&F shifts text

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

  244.             paintButtonPressed(g,b); 

  245.         }

  246. 

  247.         // Paint the Icon

  248.         if(b.getIcon() != null) { 

  249.             paintIcon(g,c,iconRect);

  250.         }

  251. 

  252.         if (text != null && !text.equals("")){

  253. 	    View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  254. 	    if (v != null) {

  255. 		v.paint(g, textRect);

  256. 	    } else {

  257. 		paintText(g, c,textRect, text);

  258. 	    }

  259.         }

  260. 

  261.         if (b.isFocusPainted() && b.hasFocus()) {

  262.             // paint UI specific focus

  263.             paintFocus(g,b,viewRect,textRect,iconRect);

  264.         }

  265.     }

  266.     

  267.     protected void paintIcon(Graphics g, JComponent c, Rectangle iconRect){

  268.             AbstractButton b = (AbstractButton) c;                           

  269.             ButtonModel model = b.getModel();

  270.             Icon icon = null;

  271.             if(!model.isEnabled()) {

  272.                 icon = (Icon) b.getDisabledIcon();

  273.             } else if(model.isPressed() && model.isArmed()) {

  274.                 icon = (Icon) b.getPressedIcon();

  275.                 if(icon == null) {

  276.                     // Use default icon

  277.                     icon = (Icon) b.getIcon();

  278.                 } else {

  279.                     // revert back to 0 offset

  280.                     clearTextShiftOffset();

  281.                 }

  282.             } else if(b.isRolloverEnabled() && model.isRollover()) {

  283.                 icon = (Icon) b.getRolloverIcon();

  284.             }

  285.               

  286.             if (icon == null) {

  287.                 icon = (Icon) b.getIcon();

  288.             }

  289.                

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

  291.                 icon.paintIcon(c, g, iconRect.x + getTextShiftOffset(),

  292.                         iconRect.y + getTextShiftOffset());

  293.             } else {

  294.                 icon.paintIcon(c, g, iconRect.x, iconRect.y);

  295.             }

  296. 

  297.     }

  298. 

  299.     protected void paintText(Graphics g, JComponent c, Rectangle textRect, String text) {

  300.         AbstractButton b = (AbstractButton) c;                       

  301.         ButtonModel model = b.getModel();

  302.         FontMetrics fm = g.getFontMetrics();

  303. 

  304. 	/* Draw the Text */

  305. 	if(model.isEnabled()) {

  306. 	    /*** paint the text normally */

  307. 	    g.setColor(b.getForeground());

  308. 	    BasicGraphicsUtils.drawString(g,text, model.getMnemonic(),

  309. 					  textRect.x + getTextShiftOffset(),

  310. 					  textRect.y + fm.getAscent() + getTextShiftOffset());

  311. 	}

  312. 	else {

  313. 	    /*** paint the text disabled ***/

  314. 	    g.setColor(b.getBackground().brighter());

  315. 	    BasicGraphicsUtils.drawString(g,text,model.getMnemonic(),

  316. 					  textRect.x, textRect.y + fm.getAscent());

  317. 	    g.setColor(b.getBackground().darker());

  318. 	    BasicGraphicsUtils.drawString(g,text,model.getMnemonic(),

  319. 					  textRect.x - 1, textRect.y + fm.getAscent() - 1);

  320. 	}

  321.     }

  322.         

  323.     protected void paintFocus(Graphics g, AbstractButton b,

  324.                               Rectangle viewRect, Rectangle textRect, Rectangle iconRect){

  325.     }

  326.   

  327. 

  328. 

  329.     protected void paintButtonPressed(Graphics g, AbstractButton b){

  330.     }

  331. 

  332.     protected void clearTextShiftOffset(){

  333.         this.shiftOffset = 0;

  334.     }

  335. 

  336.     protected void setTextShiftOffset(){

  337.         this.shiftOffset = defaultTextShiftOffset;

  338.     }

  339. 

  340.     protected int getTextShiftOffset() {

  341.         return shiftOffset;

  342.     }

  343. 

  344.     // ********************************

  345.     //          Layout Methods

  346.     // ********************************

  347.     public Dimension getMinimumSize(JComponent c) {

  348.         Dimension d = getPreferredSize(c);

  349. 	View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  350. 	if (v != null) {

  351. 	    d.width -= v.getPreferredSpan(View.X_AXIS) - v.getMinimumSpan(View.X_AXIS);

  352. 	}

  353. 	return d;

  354.     }

  355. 

  356.     public Dimension getPreferredSize(JComponent c) {

  357.         AbstractButton b = (AbstractButton)c;

  358.         return BasicGraphicsUtils.getPreferredButtonSize(b, defaultTextIconGap);

  359.     }

  360. 

  361.     public Dimension getMaximumSize(JComponent c) {

  362.         Dimension d = getPreferredSize(c);

  363. 	View v = (View) c.getClientProperty(BasicHTML.propertyKey);

  364. 	if (v != null) {

  365. 	    d.width += v.getMaximumSpan(View.X_AXIS) - v.getPreferredSpan(View.X_AXIS);

  366. 	}

  367. 	return d;

  368.     }

  369. 

  370. 

  371. }